[Music]

[Music]

Yeah, I think I can just start. Um so

the way this workshop will just be run

is we'll show a few demos of what we

built with Manis what we have at the

moment and then um if you guys have any

questions at any point in time feel free

to stop me um throughout this whole

workshop what we're going to be using is

the new manus API and it will go

basically will reproduce our original

Slackbot um so if you use our new Madis

app you can actually now use Madness in

Slack uh so hopefully it works since I'm

doing it live I'm a little worried but

uh let's see

So

I think a common question that a lot of

people are asking is what is manis and

what does manness actually do right

which is quite fair because at this

point we kind of do everything. If you

go to our website uh you see this really

long description that says manis is the

action engine that goes beyond answers

to execute task automate workflows

extend human reach. Um, if you search

for what is Manus and the new

announcements that we've made, you may

have seen Madness 1.5, manus 1.5 flight

saying that we're now faster. Um,

there's an increase in quality gain,

some user satisfaction increase, and

that we've rearchitected our models. Um,

or you might just seen a lot of stuff

that we talked about where we talked

about the fact that building AI agents

is just really difficult, right? And

it's something we've learned as we

scaled the number of conversations that

we have every day to millions and and

beyond, right? Because now we have

things like infrastructure, we have

sandboxes, we have reliability, and all

these different like considerations to

take care of.

But really what we want to do at Manis

is build a general AI agent that you

want to use in a variety of different

ways. And we really want to meet users

where they're at. And from day one,

we've been designing Manners with this

in mind. Whether you like to use Mannis

in your mailbox, whether you like it in

Slack, whether you have your own custom

programmatic workflow or you just like

to use the iOS app on the go, which I

quite enjoy. Um, we've kind of built

Manis to do that. And because of that,

um, we have a lot of different ways to

use Manis. Currently, we have the web

application, we have the Slack app, we

have the API that we just launched,

which we'll be working through today. We

have a new browser operator. We have two

days ago we launched a new Microsoft 365

integration which means that in the far

future or in the near future hopefully

um when you're writing a word document

or you're doing a presentation or you're

doing anything in in the Microsoft suite

if you just add mattis uh we'll edit

your powerpoints we'll fix your j your

janky excel uh templates or you know

just whatever needs to be done. And

lastly we also have mail madness.

And so I'll just be walking through four

different demos that we built with Manis

and you can kind of see what we've been

building for the last few months since

we launched Manis 1.5.

One of the things that I Let me see if

this works. Right. So I've been learning

French for about a year and honestly

speaking I I'm pretty bad at it. It's

not an easy language and what I really

wanted to do was to find a way whereby I

could practice it every day. as managers

to build me an application where you

know I could practice this and so the

way it works is that you know throughout

my day on my on my phone I'm just going

to key in a bunch of random prompts or

random things in mind like hey today I

had this thought today I'm stressed

about this workshop that I'm currently

conducting and once you key this in

manus then takes a language model and

finds the exact problems with what I've

written for example over here you can

see that there's an inline correction

here whereby you know life is live

forward but understood backwards, right?

And manice is nice enough to give me a

entire corrected version. But let's say

for example, I don't quite know what

this word means. Well, I can just add it

over here and say what is defy,

right?

And this is because every single Manis

web application ships with a fully

featured language model that you can

call whether it's structured outputs

that you want to use whether it's

whisper to transcribe audio or even in

this case just you know inline

corrections with structured outputs. Um

you can even integrate any sort of

provider you care about. In this case I

chose to use 11 labs because I have some

extra credits and

hope this works.

So the beauty about this is that I

didn't do a single thing and actually

the the cool part that I enjoy is that

as I'm interacting with this it kind of

creates a profile for me. It seems that

you're 28 working at manners where you

build agents and hey like you know you

your biggest strength is your

willingness to tackle a lot of these

abstract ideas and but you're really bad

at anything related to distance and time

which I get but the beauty about this is

that with you know manis like with new 1

manus 1.5 you're able to build these

really complex operations from scratch

and you know I think that's pretty cool.

I would never have bothered to code this

up. Oh, sorry.

>> Was that part of Manus' settings or the

app?

>> Uh, so this was just me prompting Manis

on the go as I was bought in between

talks at AIE. Um, so

>> user preference.

>> Yeah. Yeah. So this is just me. I just

told Manis, hey, can you keep in mind

because you know I would say things

about myself like, oh, I have a dog,

whatnot. But in languages like French,

you know, you need to bear in mind like

what's your gender? You need to have all

these like agreements. And it's kind of

nice when you get like writing ideas on

top that Manis gives every day or the

language model we invoke every day um

that gives you suggestions on what to

write.

And so this is an example of what the

new web development platform can do. Let

me just back to my slides. So another

thing that we can do is mailman where we

can use the app. So for example if I'm

using my phone uh let me try to connect

it right now. So say for example here

let's say we connect to my phone and we

go like let's say I have a morning task

at data do right um and you can just do

things like maybe I just want to for

this to reply and just say like

uh I think my keyboard is kind of

disabled on the screen sharing for some

weird reason but basically um you're

able to essentially take a lot of these

task and get manage to do them for you

right and this is an example of how you

we're able to meet users where they're

at. The newest one which I think is

pretty cool is our new browser operator.

And so I think let me just boot up the

Madness application.

And so

let's say for example we can say, "Hey

man, I'm currently at the AWS Hang 27 in

New York. I would love to get a coffee

after this. I'm jetlagged from Singapore

where I've flown over 20 hours and I

just want something really general. I

just really simple coffee. I just want

to drop by and and grab something. I'm

not pretty. I kind of just want

something simple, maybe an Americano,

and that should be good,

right? And so what you actually see is

that as Mannis is executing a lot of

this with the new remote browser

operator, um it'll think for a while. It

go through a bunch of different things

and it'll actually kickstart a browser

tab on my computer that I've set it up

on. So what this means is that for you

if you're using any sort of thing like

LinkedIn, if you're using like um you

know your Instagram, you have all these

like platforms you're logged in that you

can't access through a sandbox browser

like browser base. This completely

changes like everything that you're

using right because now Oh

man, listen. My bad. Man, can you use my

browser please? Thank you.

Oh yeah. So actually this by right

managed to have used like a browser that

I have on my computer.

Let's give it a bit of time to run.

Yeah. And so this actually kickstarts a

tab on my computer. Right. And so for

specific task whereby you need to use

these authenticated platform just

uh

a while for the computer to boot up.

Yeah. So you can see that it actually

opened a tab in my computer over here.

It looked on Google Maps. It pulled it

up, right? And what we're seeing this

actually mean is that what's really cool

about this is you spin up multiple

instances of this in parallel, right? So

you can imagine for someone with a Mac

Mini running in their basement, all you

got to do is just say every day a

schedule task, hey manners, use this and

it'll get it done for you. And these are

all things that you can do through the

API, right? Because we built a general

AI agent first and then web development

capabilities second, we can also do some

pretty crazy things. For example, um if

you look at the this uh demo that I

built over here. So,

one of the things that I found really

confusing about the AIE is that there's

a lot of different events. I kind of

want to make sure I hit all of them,

right? And I found the website a bit

confusing personally. And so, what I I

told Manis to do was, "Hey, Manis, can

you go to the website? Can you look at

the browser? Can you open a single

event? And then can you scrape

everything there for me?" And so, what

Manis did is that it actually scraped

every single thing on the single brow on

their website. It put into a JSON file

and then it loaded it into this website

for me. Um, you may notice a very

brutalist theme and that's because I

really like Chroma's website design. So

everything I build looks like Chroma to

some degree. But what you get out of

this is that let's say I am interested

in 2026, the year the IDE died. Well,

you can see that the description has

been scraped. I can add to my Google

calendar in one click. And I also have

similar events over here, right? For

example, if I'm interested in the year

the IDE died, maybe I want to check out

AMC code or AGI the path forward.

Everything that I did over here was just

built by me prompting Manis because I

was like, hey, I like this event.

Anything else I should pay attention to,

right? Everything here is because

Manners can build in with external

platforms such as Chroma. Um, and all I

did was give it a Chroma API key, an

OpenAI key, so it can do embeddings. And

now we have this. Now, my favorite

feature is that after starring

everything that I'm curious about, I can

scroll up. I can go to my timeline and

then instantly I see a list of

everything over here that is happening

for the day custom to me. And so,

yesterday I was really happy to actually

check out the new talks by Will Brown

and the applied compute guys which were

really technical. And this is an example

of what you can build with the web

development framework that we've put

together. We also have support for

things like stripe which because we ship

with a full docker image you can install

anything on it. Uh some of my favorite

examples, you've you've used anything a

bit more complex, you need a Reddis Q,

you can actually just install Reddis on

the web app and use BMQ and you're good

to go, right? Um Stripe integrations, if

you use a lot of other platforms because

they're not full Docker images, they're

not full applications, they're just

giving you a nice front end, you're not

actually able to do things like web

hooks or more complex integrations, but

we can support that. And if you use our

Stripe integration, for example, we

automatically set up web hooks for you.

We ways to test it, right? Manners can

receive the web hooks. And in the

future, we'll be rolling out things like

autoscaling, warm deployments, all the

important things that you need in order

to essentially build a single MVP idea,

right? You can integrate anything you

want. You can add any packages you want.

And please don't abuse this platform,

guys. I kind of like my job.

We It's It's been uh we worked very hard

to try to keep it uh good and cheap for

everybody, you know. Um, but most

importantly, it's like it really is the

fact that if you build a general AI

agent instead of verticalized products,

you can do so much more. And I think

that's kind of what I'm driving at here,

right? Imagine building this six months

ago. I would have to build a web

application. After I built a web

application, then I need to set up my

Chroma account. I need to get my Chroma

DB setup. Then I need to maybe find

cloud code, boot it up. After I put it

together, I now need to think about,

hey, whether I deploy it with manage, it

kind of just works. And that's kind of

the beauty of it and things will get

better, right? Uh so I talked a lot

about what Manis is and so I guess I

should move on a little bit to the manis

API which is what most people came here

for. And so what is the manus API? Well

earlier you've seen a few different

examples whereby you know we've used

manis to build websites. We've used

Manis to do things like remote browser

operation and you know manus also ships

with the ability to query things like

the notion your custom MCPS whatever

sort of like you know code they need

written because every single manage chat

ships with its own sandbox and so you

get the exact same things with the API

so so what are some things that we built

internally right the Slackbot is the

thing that's public facing our Zapia

integration is built on our API our N8

integration is also built on our on our

API Okay. And we built a lot of our own

support bots in house whereby before

anyone looks at it, if it's something

that's important, manice can go to the

chat, click on every single message, and

at the end it gives a full report with

screenshots because it has a browser of

everything that you can do. And so I

really liked what I built internally and

so I thought, why don't we build it

together, right? Um, this isn't very

complicated and I I kind of hope Stripe

and Modal work nicely. So we'll see. I

hopefully fingers crossed. Um but

through this we're going to work through

a lot of the simple ideas. Um we'll be

looking at a few different notebooks. If

you want to sort of um see the notebooks

um I have them over here at this link.

So a tiny URL slashmanis API workshop.

And so in order for you to get started

with that you'll need a manus API key.

Um if you have a normal manus account

the billing for the API is exactly the

same as if you took a chat. So whatever

you would spend for the same query in a

manus chat on a web app, the API would

cost the same. And really for now, this

is a this is what we want you to do

because we want Manners to meet you

where you're at, right? We don't want

you have to worry about if I use the

API, is it more expensive or less

expensive? Is the chat different? Should

I use the Slack integration? We want you

to be able to we want to provide a

custom customizable way for you to be

able to work with Manis. And so um this

is the tiny URL link and I'm just going

to proceed on to the next bit.

So the first thing we're going to do is

going to look at some of the API

fundamentals. Um so I have the API over

here. Um you need these three

environment variables. I tried to make

it very easy for you to set up Slack

even though it is a pain in the ass. Um

so here are the five notebooks I'll be

working through. And if you scroll down

a fair bit, I have the screenshots on

how you can actually get your own Slack

tokens. Um,

so let's begin.

So the first thing you need is basically

a manis API key. And once you have the

API key, you need to put it in this

envir.

I've provided basically the ENV

variables you need in av.

But you basically need a manus API key,

a slackbot token, and a slack signing

secret.

So, let's load it in.

Okay, I kind of need to

Holy that was tough. Um, so you

can see that now that we've loaded it in

from our EMD file. Um, let's test it

out. So,

we're just going to check what files

we've uploaded prior to this. And

because this is a fresh account, we

haven't uploaded any files. Um, you're

just going to get object lists if not

normally have a data property. And so,

this means that our API key is working

as intended. Um, one of the benefits of

using the Manis account is that we often

have a lot of clients that come to us

saying that I have sensitive files. I

have things that, you know, I want to

make sure no one else is able to see.

And so, every file that you upload to

the manage API, files API, it's

basically going to be deleted

automatically in 48 hours. And so, that

means that whatever sort of temporary

file you're using, if you delete the

session, you can delete the file at any

time. But if you forget like, oh, I

upload this file, maybe I want to use it

later, we will delete it for you, right?

you have to delete the session for that

file to be gone.

Okay, cool. So, we validated that the

API key works. So, let's create our

first task. Um, I'm just going to be

using the pure request here where I make

a core request, but in our documentation

at open.mmanis.ai,

we do also have support for things like

the OpenAI responses SDK if that's

something you're using. Um, if you're

using any sort of AI framework, I I've

heard a few at this conference like AI

SDK, Copilot, AG UI or something like

that. Um, there a whole bunch of them.

Please feel free to reach out to me. I'm

happy to try to see how we can make that

work. So, let's try our first query,

right? Um, let's ask Mannis, what is 2

plus2? Please provide a brief answer.

So, let's

run it. And when you run your first

Madness API task, you see that you get a

few things back. You get a task ID. you

get a task title and you also get a task

URL and so these three things are really

important particularly the task ID the

reason for that is that when you

interact with manice and you're using

manice as part of your workflow part of

your application you might get things

where manage will ask you for certain

bits of clarification like I'm sorry

like I need to understand a bit more

what do you exactly want or come back to

you and with some sort of data and you

want to actually give some follow-up

feedback and so by keeping the task ID

around you're able to push to the same

session

So, let's click a bit on this task title

that we've gotten back.

And

I need to Oh, did I use the wrong API

key? I think I used the wrong API key,

guys. I'm sorry. I will load a new API

key for myself.

I think it's this other one. Oh, yeah.

Yeah. So you can see what is one what is

2 plus two and then you got four right.

So this is the basically we when you

don't specify a chat mode we have a

router on the back end that tries to

determine if you need to use basic

simple chat or the full-fledged manus

agent and I think this is something

that's pretty uh simple but if you want

full fine grain access we can those are

parameters you can set on the API.

So

if you've looked at the agent profile,

right, the basically the profile, the uh

payload that we sent over, you may

notice this agent profile, manus 1.5. We

talked about it briefly at the start,

but there are two kind of models that we

currently use in manus. One is manus 1.5

and one is manus 1.5 light. For a lot of

these more complex tasks, we highly

recommend using manus 1.5. For example,

both of the websites earlier were coded

1.5. If you have very simple queries,

things that you want to execute a bit

faster, we recommend 1.5 light. So for

this workshop, we're going to be using

1.5 light because we want a faster

response, but also a lot of the things

that we are working with are not that

complex.

And so

with this new agent, you have a lot of

things like unlimited context

management. So what that means that once

you go beyond the sort of length context

window of a normal model itself, like

whatever model we're using under the

hood, we do a lot of smart context

management. And because for us when we

design nice we try to make sure that the

KV caching is very high. If you read our

article on you know context management

by peak or CTO in um tune um most of

this means that for you the responses

are fast and quick and so the easiest

way is just to say you can just pull man

right so let's start another task look

up the weather in New York City and then

ask me a question about it right

okay so you can see that the task was

created successfully and you get a task

ID a task title and task URL Now, if you

want to just pull this, it's pretty

straightforward. Um, there are basically

three states that the manage agent can

be in. They're going to be either

running, pending, completed, or error.

Um, ideally, you never see error. Error

is a very rare case. You also have

completed that means the manage agent is

done. Pending is when it's it requires

more input from you. And so, currently,

we're pulling over here and we're seeing

that the task is still running. The

progress of this is it task. Take a look

at it.

The weather in New York City over here.

So, Mannis is currently waiting for a

response from us. So, I've looked up the

weather forecast. My question for you is

given the rainy forecast for Monday or

Tuesday, would you prefer to plan an

indoor activity or an outdoor activity

for one of those days? Right? So, we see

here's all the here's what you get back

when you actually query the information

on the task. You get the credits you've

used. You get the response back. This is

sort of similar to the OpenAI responses

SDK, but basically we expose everything

to you. And so you get back basically

your messages and the messages that

Manis sent to you. And so let's say in

this case, if we look at the original

chat, man said that given the rainy

forecast, would you prefer to plan an

indoor activity or an outdoor activity

for one of those days? And if so, which

day and what kind of activity would you

prefer? Well, I guess in this case, um I

guess I'll

I guess I'll prefer an indoor activity

on Tuesday. I'll probably choose

probably an indoor activity

on Tuesday.

So, we let it run for a bit.

And you can see that the the same sort

of message was pushed to the same chat.

And what this allows you to do is ensure

that as you're running more and more

complex workflows, you're able to ensure

that all of your context is kept within

the same chat.

And so you can use the same polling

interval. This is a very simple pattern.

As you're prototyping in the Manis API,

polling is the easiest way to get

started. And then in the third notebook,

we're going to look at basically how to

use web hooks. Um but for now, I think

polling is pretty straightforward. Um

you basically just check to see what is

the current status of the task given the

four sort of statuses that we talked

about running, pending, completed, and

error. We take those and you can

determine what to do next in your

application.

So this is essentially the first core

mechanic of the manage API. We talked

about authenticating your connection to

the manage API. Creating your first

task, managing the entire asynchronous

life cycle from running a task, you

know, really doing like the initial

polling and then we also talked about

how to push to the same task. So what's

really important when you work with any

sort of language model is you need some

sort of context, right? Um, sometimes

that might be a PDF of your own

policies. Sometimes that might be, you

know, some sort of system you want to

upload. So, we have three different ways

to do so in the manage API, right? As

usual, I've defined a small library over

here, env.y that does basically the same

things that we did in the previous

notebooks. So, you can see over here,

all we do is we just test given a files

API and then we return the env key.

So, let's see how this works.

It's loaded into us.

So now we have our API key and the base

URL loaded in. So what I really love

watching is Rick and Morty. And for a

long time it was one of the funniest

shows that I enjoyed. And actually they

have a free API. And so what we can do

is we can grab the first maybe 100

characters from Rick and Morty and let's

get mad to figure out like what exactly

Rick and Morty how their characters have

been. So we fetched everything and we

can just save it to a Rick and

Morty.json file, right? Rick and Morty.

Jason. So this is how how it looks like.

We have every single character. We have

the episodes that they've been alive

for. And over here you have Morty, you

have Rick status, and you have the

origin, their current location, and a

short image about them, right? And so

with the manus um AP, we support this

thing. We support file uploads. And this

is much more useful if you have

sensitive files, files that are much

larger than normal. And so this what we

basically do is if you give us an API

key if you give us let's say if you send

a request to us and say hey I want to

upload a file in this case it's called

Rick and Morty characters

correctors.json

what we're going to do is we're going to

check on our database going to save it

and then we're going to give you an ST

link and so what this allows you to do

is be able to upload much larger files

and all you got to do is do a put

request. So we've created this file and

you can see the file ID is basically

file JQ

you get a file ID that starts a file

basically and then we're going to tell

manis using the attach Rick and Morty

correct data set let's create a simple

and visually appealing website and so

we've uploaded the file and let's take a

look at the anis website over

Just check. I think it's in my other

account.

Yeah. So

you see over here that basically Rick

and Morty we've uploaded the file. If

you upload any images, any PDFs, we

already come out of the box for for

things like paring a PDFs, looking at

handling all that multimodal content. So

that's really useful for you, right? So

let's manage this is going to run. It's

going to create his website. We'll check

back in a bit. But this is basically the

first files API. And if you have large

files that you know you might want

automatically deleted at some point,

this is a really useful way to do so.

The next way that you can do so you also

have the ability to delete this file at

any point in time and this is an API

call that you can run. Next way you can

do so is if let's say you're using a URL

attachment, right? A lot of times you

might have a brow that comes from

something like circleback, right? You've

you've just done a call, you have a

transcript, you want to send it over to

Manis. And so we actually do support um

raw call transcripts. So what I've done

is I have basically created a fake

transcript.

Yeah. Uh so I think this file was

deleted by me accidentally.

That was good. Warren Buffett.

So thankfully Burkshshire had way like a

bunch of investor letters and so we can

just provide a PDF link.

So instead of a transcript maybe this

we're just going to just do like Warren

Buffett.

This should work.

This works. And then maybe we want to at

this point we want to analyze given this

investor letter that we have. Can you

help me parse out you help me summarize

it and give me some insights into what

the company is looking to do.

Right. So,

so now we can start a task um that

automatically out of the box works with

these public urls. One of the things

that I actually wanted to show over here

is that with a lot of these um basic

task um any of the connections that you

have in manis for example Gmail notion

that you've already configured ahead of

time these all work out of the box and

all you need to do is basically go to

manis um let's say our website is over

here you look at the connection over

here if you go to manage connectors you

can use any of these connectors just by

copying this UID over here if you copy

the UID and you add it as part of the

connectors payload um it will work out

of the box for

We also support things like basic

before. Um, so this example over here,

we just had a simple 404 page. Um, this

was a screenshot that I took of a page

that man has created. And so what we

want to do over here is create a

automated automat automated bug

investigation task. Right? A user has

reported that the settings page isn't

working. Let's give this B64 encoded

image to manage and let's see how it can

figure it out. Right? Can you beat Dara?

Here's a website that we've created

ahead of time. And can you figure out

what exactly are the problems with this?

Right.

So, this is a simple Manis web app that

I've created. Um, actually, if you go to

the settings page, you get a 404. There

also other few pages that also have

404s. So, let's see how Manis performs

in a bit.

>> So, if you look at our Rick and Morty

character data set, manus sort of

characterize all of this in a pretty

cool website, right? You have the gender

distribution. You have male, female,

unknown. Rick Sanchez is obviously alive

as is Morty since it's Rick and Morty.

And you have all these other characters

that's that are uniquely sort of

characterized and visualized over here.

For a lot of these internal tools, you

can imagine that if you have a lot of

data you want to search through, you can

create a simple website just to

visualize all of them out of the box.

And that's pretty useful.

Similarly for this investor letter you

can see that we uploaded it and man has

actually detected that even though I

called it call transcript.json it looked

at said that the file is a PDF not a

JSON text and then it completed a

analysis of Warren Buffett's investor

letter and it gave like this whole

analysis at the end. One pretty cool

thing is that we can take this um simple

we have the task ID and so we go back to

basics over here. Previously we had a

thing whereby we said you go to request

get URL.

Let's see. I think just grab this

picture here instead.

Um this is not working as I thought it

would. Um

what I wanted to show was actually that

if we go to this specific um one over

here, if we go to manice

actually return

just want to show like the

not JSON.

Yeah. So actually if you look at the

output over here you notice that over

there man has created a markdown file

and based off the markdown file you can

actually you get back the full file URL

the file name the mime type this is

really useful if you want to do some

sort of processing down the line with it

right and so with this we've covered

things like how to use the files API

we've looked at basically how to up use

publicly available URLs in manice and

we've also talked about how to basically

be able to use basically for encoded

images and so let's think a bit about

web hooks right So in the previous

example, we created a task with manness.

We uploaded some files and the way that

we tried to determine that, you know,

the the thing was basically completed

was that we pulled it every 20 seconds.

As you're scaling out to more and more

tasks, what you really want is what's

called a web hook. What a web hook does

is that when your task is completed,

we'll send you an API um request and

that will basically notify you that the

task is done. So a really easy pattern

over here is that you want to wait for

the task to be completed. you get the

web hook and you get all the information

about the current task.

So in this case, this is really useful

because if you're building any sort of

complex application, if you want to use

this task at scale, it's not really

viable for you to be able to sit there

and just keep holding the API. It's

going to be a bit complicated and I

think not the best practice for you.

You're going to basically have a lot of

workers spinning. But if you use like

web hooks, uh this is a much more

sustainable way for you to do whatever

sort of agent you're building at a much

cheaper cost.

Okay, so I'm going to just use modal

over here because it's a bit simpler.

I'll have the modal code on the right

and then I'll have the manus uh notebook

on the left. Let me just load up my

virtual environment.

And

basically what modal provides is it

provides you the ability to deploy

simple like um Python applications. Um

in this case it's a fast API endpoint.

And so

mod surf server.py.

So what you can see if if you run mod

surfs server.py is that we now get a

public endpoint that we can use, right?

And this is pretty straightforward. Um

if you run it on your own computer with

modal, if you set up an account, you get

$5 free. This basically gives you like

an endpoint that you can now hit, right?

And so let's get the Oh, I think someone

already hit my end point.

That's a bit stressful. Okay, guys.

Please be nice to my end point. Um, but

you can see that over here um in these

over here. Oh, wow. Another person's

hitting my end point. Uh, all right

guys. Anyway,

>> maybe it's streaming in. That's kind of

awkward, but uh anyway. Yes. So, um, if

you basically want to register an

endpoint web hook manus and you register

web hook with us, when a task is created

and when a task is stopped, we will send

you two web hooks. And what this allows

you to do on the front end is that then

you know when you send a request to us

whenever we started processing your task

and when your task has been completed.

Um the typical manage task is going to

take roughly three to five minutes and

if you have something that's a bit more

complicated this is going to be you're

not going to want to send that and pull

and so the web hooks are a good way to

do so. So let's see over here how we can

mimic a web hook that manage send over

here you have a test payload message

ended. I think that's what people were

running with my uh URL. And so um you

can see now that this is a really useful

pattern because if I'm building and I

have like hundred man tasks running at

once, right? I don't want to keep

pulling for all of them. And so with a

web hook, I can easily receive a lot of

these notifications as they're running.

So let's register this web hook with

Manis. So all we got to do is basically

post to Manis. Um I you have a base URL

that we have uh manus

api.mmanis

imi let me just double check I think I

have that the base URL is api.mmanis.ai

AI/V1. And so if you post that, then you

will register a web hook successfully.

And in this specific case, the web hook

we want to register is this one over

here. You go to the Manis um

connector setting over here,

integrations built with manus API. Um

you see that this is it will appear

basically over here the new webbook that

you've registered. And so whenever you

create a task, it will automatically

send you a notification over there.

So let's create a simple task. Hold on,

people are still sending me. Um, and so

let's create a simple task over and then

try to get it working. Yeah. So we

created what is 2 plus2 provide a brief

answer. This is over here. We seen that

the task is running and it's going to

think a little then it kind of just runs

like echo 2 plus2 VC or whatever that is

and then it will send you an answer. And

so you can see over here that now that

the task is completed, you get the full

payload over here.

This is kind of what it looks like. And

if let's say we paste this

JSON

but basically you get back um at this

point you get the ID of that you have.

So what this means is if if you have

multiple sort of manage tasks that

running you can identify them by the

task ID. You can also get back the

current task URL. You get the output of

it which in this case the status is

completed. We sent that we sent to

manage what is 2 plus2 please provide a

brief answer and then we said let me

calculate that for you and people are

really running it quite a fair bit. Um

and so now that we've actually processed

the web poker notification um what we

might want to do is we want to just get

the entire conversation history. And so

to do so, we can set a simple secret

over here. And so what this allows you

to do is that when you're running your

modal server, you basically are able to

make a request to the Madness API and

get back um a list of every single um

chat message that's been happening in

there. I've done this ahead of time and

so

we can just

put this over here.

So all this does is that if it's done,

it just get a full request and it gets t

details. And so what you saw with there

was basically what happens uh when we do

this ahead of time.

So now let's um so that is basically web

hooks.

>> Yeah.

>> So in the previous so right now we've

looked at how to create a task. Uh we've

looked at basically how to upload files

and then we've also covered like how to

use a web hook. Um

so let's now look at basically how to

use slack which I think will be a lot

more fun. So in the previous notebook we

looked at how to use web hook. So case

we're going to start integrating on

slack. I've created a Slack workspace

for myself. Uh it's just on I personal.

And so in this small channel over here,

we're going to be interacting with our

manage chatbot.

So first thing you want to do is you

want to make sure that you have your

Slack um signing secrets. These are

basically I have instructions on the

read me on how to get the bot signing

secrets. Then you want to basically test

it. Slack provides a off test.

So in Ivan personal for the bot mani you

can basically test to see that your

secrets are working as intended and so

this is really important because if your

environment variables are not correctly

set up then you're not going to be able

to do this.

Okay cool let's run this bit by bit. So

we're going to just start by defining a

simple um slide simple bot over here.

Just going to call this

bot. Y

and so let's run mod surf chat.

And so when you run this black ipy,

you'll find that what you need to do

then is

we've initialized a simple model app.

We've added some dependencies. We have

the slack secret over here that we

stored ahead of time. And then we just

have a single endpoint over here that's

called slash web hooks slack. And so you

will have something like this where you

have like a simple like endpoint that

you can hit. And so in my case um this

will be the endpoint that I have right.

And so you can see that if we hit this

endpoint over here

it takes a while to run

but basically get back status. Okay. And

so what this means that this is a

publicly available like endpoint for you

to hit. So when you mention anyone on

Slack, for example, over here, um before

our bot is configured, if you just

something like money like what's up,

um you're going to get a message from

Slack similar to how the manage API

worked, you're going to get a web hook

with some sort of payload. And this

enables you to essentially be able to um

look at the input and you're going to

get something like um

so you're going to get like some sort of

information from stack, right? So we

have this um

over here. Let's go to Slack API.

Slack.apps,

right?

So we want to just make sure that

so previously we made sure that the

Slack that that our server was able to

receive a response. And so the next step

that we're going to do is we're going to

make sure that our server is able to be

registered as a web on Slack. when you

actually make a request to Slack, you

need to make sure that when you respond,

you actually get back you get back a

challenge URL. So,

this is what you can see. We just rerun

this. And we have this URL over here.

And then we're just going to put

inside the event subscription,

right? Right. So this is verified and

what happened was that you know Slack

basically sent us in the API request and

we were able to successfully respond to

it with a challenge.

And so if you see like a verified over

here you just need to save the changes

and that should work you

see.

Right.

Then once you've done this,

we mentioned our bot in Slack. Let me

just check.

We should get a API request from stack.

And so you can see that this was the

mention over here. So over here I said

add money what's up and over here you

see here's a text what's up right

and what you find is that if you just

get the raw text you're going to get the

user ID and that is something that you

want to parse out in the response

cool so let's try to figure out how to

respond to Slack over here right if I'm

just going to copy and paste this entire

Slack event that we previously

So this is the Slack. I'm just going to

paste the Slack event over here so that

we're able to

have it for context. And

when we want to send a response back to

Slack, what we need is basically the

channel that was sent in the thread TS.

And so that's how Slack identifies the

right item. And so let's get it from you

can really get it over here. So

you want to get the channel

then you want to get the event. Yes.

Right.

So let's send a response. And you can

see that in Slack over here we got a

response that said hello world. And so

this is really kind of how your

application will work. If you're

building a Slack bot, you get a you get

an API request from Slack and then once

you get the API request from Slack, you

do something and then you return it

back. One of the things to note when

you're building on Slack is just that

you need to send a response in roughly

like 3 seconds. Uh if not, they're going

to try again. And so if you're building

any sort of Slack bot, you want to

ideally keep some sort of server warm.

So let's try again to maybe, you know,

in this case, we're going to send some

files over here. So let's say we want to

send

the bookshyway Bshireway 2025 investor

letter. Well with Slack what you can do

is you can basically just upload the

file first. And so let's try uploading

it to the right channel

and let's upload it here.

So now we have it uploaded to the

channel. We have an ID and we can

actually post the same message over here

box. So I've added so previously you saw

that we got a Slack file ID and then

when you have the Slack file ID when you

post a message you just upload a file we

get back a list of ids and that is

included as part of the attachment

itself. And so let's say over here we're

going to take this the channel that we

previously used

the event. Yes,

this does not find.

Yeah. So if you look back at this chat

over here, you can see that we sent we

essentially first one over here uploaded

it to the channel and then the second

one at the bottom over here basically

sent the same thing over there with

hello world. Um one of the problems you

find over here is that we actually

didn't upload it to the right thread,

right? We uploaded to the channel and so

when you're working with files in Slack,

you need to make sure that you keep this

in mind. And so this is um basically how

you work with files in Slack. And so

let's now try to get Mattis involved

over here.

Okay. So now we're going to build slide

integration.

So up ahead we had these functions over

here and so we can just use them to just

add it in.

Okay.

We're going to add this Slack message

over here using at night event. That's

from the Slack SDK.

So we previously defined a function

called postlike message and so let's

make sure that we have that running.

Then we had a bunch of different helper

functions up here. So let's uh make sure

that we also copy them. Right.

So data class is not defined. All I need

to do over here is just define a data

class. Then file I file ID.

Cool. So, now that we've added in a

whole bunch of these different things

that we previously had, um,

let's see how this works on the main

Slack. Uh,

we just add this portion up here.

So with this what our goal is to

basically to reproduce what we did in

the notebook manually. So let's try to

see if this works out of manner group is

not defined.

So now that we've started up then

so we had a small bug over there and so

previously what we did in the previous

portion was that we tried to basically

uh get Slack working with a web and so

what I did wrongly was just that if I

I didn't define like the manage URL and

so let's just have it run over here.

So you can see that now we have a

response of what we did manually just

copying it bit by bit right and so this

mean with this we've now figured out how

to basically work with slack if I send a

message I can get a web hook and I can

process it with my modal server right

this is a really simple sort of approach

but it's really useful when it comes to

doing anything else you can imagine that

for you if let's say you're doing some

sort of complex processing you might get

the user's information get some sort of

metadata from the user fetch the prior

conversations and then actually start

sending the task over to manage to start

executing

So let's now see how we can actually get

this running with manus. So

I have a function over here called

create a manus task. It does something

very similar to what we did previously

which was that we'll post a request to

manice. We would have a basically an

environment variable that we send it

along with and then we would then in

this case just send a prompt. Right? So

let's test it out. create a manage task

and then instead of this over here,

we're gonna create a manage task.

Then we're going to take in event

task ids like this and then we say file

created successfully. You can view it

here.

So I'm just going to add a simple um

wake up function so that we can just

wake this um SP.

>> So let me just go back to the web app.

Sure it's running. It's woken up. And

then let's try to kick off a task in

Madness.

What's the status in New York?

Oh, so now we've uh got a post request

and manus replies with the fact that

hey, we've created a task successfully

with Mattis. So, let's take a look at

this task and see how it's been. Task

should appear inside here. What's the

weather in New York? Right? So, one

thing you've noticed is that we don't

actually get the response. Right? We can

send these um current task over to

manage. We can pick some of these task

off, but we don't get the response. So,

let's see how we can

fix that. Yeah.

So,

what we're going to be doing is we're

just going to be checking over here.

Sorry, let me let me go back. Sorry,

guys. I'm just a bit stressed out today.

Okay. Anyway, one thing that um we saw

just now over there was that this is

kind of an ugly setup. And so what we're

going to be doing is just making it a

little bit prettier. Um if you notice in

the text you get the basically the ID of

the um user. In this case when I tag

Manny add Manny you sort of there was

this really ugly section over here where

it said um you look at the text you get

this 09 FDL. If you use the Slack API

what you find is that you're basically

able to get a list of all the users and

you can then do some parsing. You might

have some additional data on like what

exactly that this user represents in

your database. But over here, we'll just

try to make it a bit prettier for now.

So, we're just going to update the post

like

Slack message.

So,

we're going to just update this message

over here.

Then, we have a bunch of these different

types. So, we just need to update them.

Then, from typing, we'll just add

optional

Then the Slack response up here.

Slack response.

Yeah, we just need to import the Slack

response. So we get something that's

typed. And that should be

And so

now we post a message. We have blocks.

Um,

so we're just going to make this a

little bit nicer. over here with Manis.

And so what this means is that over

here, Slack has this wonderful thing

they ship called Slack Blockit. So you

can c if you've used a lot of these

Slack bots previously, you'll find that

they ship these nice little buttons. And

so you can actually do that out of the

box with this thing called blockhead. So

what we'll be doing over here is we're

just going to add this thing called we

started working on our request. And then

we'll add the URL over here and a little

emoji called view on web. And the URL

over here would just be the task URL

that we have. And so with the post like

message, we can just add blocks to be

blocks.

And so

since the blocks will be sent over, I

think we can let's see if this works.

Let's hope this works.

And then I'm just going to go back and

remove the original. Since we're no

longer using the text, we can just use

the box. And so let's remove that.

Let's wake up our server a fair bit over

here.

wake up our server. Make sure it's

running.

I'm just going to ping

what's up.

Cool. And so, oh, additional argument.

So, I just put over here. We can just

put like text

was created. I think we don't need it.

text over here because it's good to go.

Yeah, let me try it again.

So, this um essentially you can see that

now we have a much nicer enriched sort

of UI and if you click on this um you'll

be able to essentially see like a

message over here. Hey, I'm Manis. your

friendly UI, friendly um chat assistant.

What do you need from a me today? Right.

Cool. So, with this, we walked through

how to create a Slack um task. Manners

can now actually receive a message from

Slack. And so, one thing that's pretty

useful if you've looked at basically any

of our our Slack bot is that it can take

multiple conversations. I send a

message, man responds, I send another

message. Um yeah, so what you want to do

is you want to just enable multi-turn

conversations. And so the way you want

to be able to to do so is that you want

a way just basically to store if you've

seen this thread before, right? Because

if every time you send a message and you

want to post to the same thread, you

need to kind of keep track of that. And

so what we'll be using over here is just

a simple dictionary that Moto ships

with. If you're using anything like

Cloudflare, you can use like a KV store.

If you're using some sort of database,

these are things you can load into the

database. But that's basically um what

you can use out of the box. And so Moto

has a pretty uh good dictionary um out

of the box that we're going to be using,

but I think it's good to get a rough

sense for how it sort of works. And so

what we'll be doing is just be adding

two simple endpoints uh that we can use

to post and set um these requests.

One set. And so we'll be adding them to

our actual server.

Let me just fix this.

So we just need to make sure this uh

demo tick is added inside this.

Yeah. Okay. Cool. So now we have added

these two new endpoints and so we'll

kind of get a sense for how the modal

dig works before we actually start going

into how to use it with the other chats.

So

over here um let's say when we get a

chat previously we talked about how

you're going to get some sort of

response. You get a task ID, you get a

task URL, but we also kind of want to

store things like what is the Slack

channel, what is the Slack thread ts,

what is the Slack user, what is the

status of the current job, etc. And so

by using something simple like a

dictionary where we can serialize basic

key value stores, we're able to do this

quite simply out of the box.

So let's see over here um let's say we

start a simple manage task, right?

And we get back some of the task data.

We get the

over here we look at the stored value.

We store the task. We just put a random

you know like task ID over here and then

we store like task ID, task URL, Slack

channel etc. But you can also get back

when you retrieve this. So when you hit

the same endpoint, right? This gives you

back what you want. And so this is

essentially how the model dictionary

works. Simple KV store. And so that is a

relatively simple way to use it. And so

let's try to use this model dictionary

so that we can actually push to the same

task. Right?

So let's first delete these two um

endpoints that we have

and then let's create a new task map

over here

that we can basically use

store basically a mapping of a tread ID

tread ts to a task.

So let's uh we already have a function

to create the manners task and so all we

need to do is that you know um up here

like what we mentioned earlier when you

actually mention a bot in Slack right

you're going to get this weird um thing

and so what we want to do is we want to

just basically parse it out

right so here's a simple function that

we just parse it out Um, we'll then

check in the thread map whether or not

this thread ID has been seen before. And

this is because when we get the web hook

from Slack, we're going to see the

thread TS. And if we've seen this thread

before, we want to basically push it to

the same task using the task ID

parameter, right? And if we've really

seen it before, we're just going to add

a simple reaction over here, which is

just, you know, the goo the eyes that

you've seen a lot of Slack bots have.

You know, if we, hey, I'm on it. I've

notified, you know, this works out of

the box. All right, cool. Let us copy

this,

right? And then we have this new

function called handle manage task

handle select message. And so this will

essentially

replace what we previously had over

here. Right?

Cool. Let me see if this works. I right

let's we have a new server let's boot it

up again let's go to slack and let's

just say

hey man what's up right and then our

server boots up it will respond you can

see over here we created a new task with

shred ID and then let's say we go into

this task itself and we say that okay um

add any

what's the

temperature

in New York, right? And so we push it to

the same task. So task ID, create manus

task, got an unexpected one. Okay,

sorry, this is on me. Um, so all we need

to do is we just need to update the

create manus task over here. So it takes

a task ID parameter.

Then what we want to do is we just want

to take this JSON over here. We're going

to make sure that if let's say we

provide a task ID, we add it to the JSON

payload that we sent along.

Let's call it

>> cool. Let's uh give it a while for our

server to restart. Let's boot it up

again and then let's give this a shot.

We could just send the same thing again.

Wouldn't issue. So

this will hopefully you can see that

right now we have this reaction. That

means that you know we've read from the

dictionary. We've seen that this is a

thread that we've seen before. And

basically what we do is we push it to

the same task using this this task ID.

Right? So let's take a look at the live

task that's currently being executed.

You can see that this is essentially

we've with our first message. We've then

push it the same follow-up message over

to the same thread. And this allows you

to basically be able to work with a lot

of these uh simple integrations like out

of the box.

And so right now um one of the problems

is that you know the final answer never

makes it back to the user in Slack. And

so what we need to do is what we did

previously um when we were basically you

know working with web hooks is that when

we get a web hook address from manus we

need to make sure that we push it um

make a essentially we we post it back

right over to the same thread and so

that we respond correctly and so just

give me a while let me code it up and

then we can walk through the code.

Then the last bit we just need to upload

the let's just say upload files.

That should work. Hopefully

upload files just need to be uploaded.

So it also takes an hts

over here.

Okay, cool. So, the entire so and then

we just need to add the final endpoint.

Sorry, please bear me for a bit and then

we can walk through the code for a

while.

Cool.

Cool. So with this now we have a a way

whereby you know when manus actually

gives a response it's actually able to

respond to you. So let's let's try let's

try it out and then we're going to walk

through the code of what we've exactly

implemented like step by step over here.

So as usual um let's

wake up the server a little bit and then

we're just going to say at money what's

up

right. Um, same thing as usual. It's

going to hit our endpoint and we're

going to create a new task and we get a

response over here, right? Started

working a task. Task ID is this and view

the live task. It's just going to

execute um as usual. And then once it's

had a response, we should get back the

web hook slack.

[Music]

Let me just see what's should be getting

back this response at web hooksman.

Let me just uh debug this for a bit.

I'm just gonna bounce ahead over here. I

feel like I'm encountering some

technical difficulties, but I just want

to explain a little bit of what I'm

happening. I'm really sorry. Um,

basically what's happening over here is

that we have a simple um Slack bot,

right? And as as Mannis is sending us a

response, it's basically going to be

able to have um what we essentially are

all of the different um bits of markdown

that Mannis is giving and sending back

to us. Right? So this is really useful

because a lot of times manage will

output markdowns such as tables, text,

images, etc. And you really want to make

sure that's rendered nicely. Uh it's a

bit complex in Stripe to be able I'm

sorry, a bit complex in Slack to be able

to do this. And so what you have to do

is do a bit of transformation. And so

what we've essentially done if you look

at the notebook is

first when we actually create a new task

we save it inside this task info map

right we then convert it over to a slack

markdown format and what this does is

that it basically just passes some of

the existing markdown and so that it's

compatible with with with Slack. Slack

has some unique markdown formatting

issues and so we just need to make sure

it's consistent and then we then take

this markdown and format it into slide

blocks. Uh we then also up previously we

had a upload file as a function and what

you notice that we uploaded a file. It

was always uploaded to the main uh

channel but not to the tread. And so how

you can solve this is by passing in

basically both a thread and a channel um

parameter. And so what this means is

that when Slack uploads the file it will

go not only to the channel but the right

thread. So this is really useful in that

sense.

So I think in the next portion we're

just going to try to implement it so

that you can sort of um basically have

it a process and invoice. I'm just going

to use the final um code that I've

written ahead of time so that you know

in case of any technical difficulties

again. Um but I just wanted to pause

here and see if there's any issue any

questions about how to work with the

API.

Cool.

So, let me just test to see if this is

working.

Just going to maybe

think I had a bunch of uh images that I

gave previously. So, I'm just gonna take

a take this uh picture of a bunch of

bagels that I bought previously.

Uh been eating a lot of bagels since

I've gotten here. So, those are pretty

good, actually, cuz uh like I was really

surprised by um how good a lot of the

bagels were. Um but the other day, I

feel like I got I got scammed a little

cuz I I ate a bagel that was like 90%

cream cheese, like 10% salmon, and I was

a bit sad about that. And so, um yeah.

So really like what this does is that if

you look over here the first thing that

we get is you get a slack web hook, you

create the file, you create the manness

event and then we're going to post a

reply and over here you can see hey

we've started working on your request.

Um if we go over to the manus app over

here um you see that we have this thing

called a connector right and this is

basically notion that's out of the box.

What I've done is that I've created Oh,

sorry. This actually Let me just create

go to the fake one.

Yep. Anyway, um, so we actually have a a

notion where we have like the these like

company policies and I've created like a

fake company policy for you to reference

and so what you see over here is you

have all this information like the

company home like what exactly is

happening and manage is actually able to

look at the notion look at the

connectors and actually give a response

for how exactly this um is sort of

related to my actual like claims policy

and this is really useful if you're

building anything related to some sort

of internal deep research sort of API

because you're constantly going want to

be able to reference certain things that

you have. You can see that the file over

here was uploaded successfully and then

man is able to use OCR to basically

extract all the details on the receipt

in some of the previous tests that you

know you can you can see that there were

a lot of tests. Um, you can basically

see that, you know, I just spent like uh

$30 on cats in New York. Is that the

cover? And man is basically able to

respond, look at the company policy

that's in notion, which you know, anyone

in your company can edit, right? Notion

is a pretty accessible sort of platform

and then they can take that and actually

edit it out of the box. So, as Manis is

generating its response, we're waiting

for the final web hook to be sent. And

so,

let's give it a bit of time.

Yeah. And so what you kind of expect to

see is that if you give, let's say, can

you help me update this basic invoice?

Can you find the shop details, please?

Thank you. And then manager is just

going to ask, hey, can you give me a bit

updates?

This one over here, you can see like if

you look at the invoice, you know, what

are the summary details? The merchant

Tomkin SQL, what's the amount? Can you

update it using a markdown table

instead? And it was basically able to go

to the the right page over here.

realized that you know the exact receipt

that I had was basically from the dates

of like 18 to the 28 and then I was able

to update the right notion page and

basically say that hey these are all of

the different expenses these are

actually my expenses for the last few

days um and you can break it down based

on this fictitious company policy. So I

think this was a bit of a more complex

uh project and I think at the end there

was some issues with live coding but I I

just want to basically bring it back and

try to say that um the manage API is

basically a really easy way for you to

build a lot of these complex um

applications out of the box right um you

look at the Rick and Morty dashboard

that we had um you can see that this is

pretty pretty cool right like and if you

look at the let's go back to the slides

It's

my slide somewhere.

Yeah. So, a lot of what you can actually

build out of the box with the manus API

is that these are things that we've

learned out of the box scaling the

number of conversations that we deal

with every day to millions of

conversations. Right? So what this means

is that if you use the manage API, you

do have the ability to use any sort of

integration that we ship with. You can

provide your own sort of keys. You can

really just you know um add any sort of

custom code that you have, upload these

files, toolkits for manners to use. And

this means that without you having to

deal with all that stuff, you can

actually focus on the core business

logic that you care about. And so um if

you have any API inquiries about the

Manis API, um feel free to reach me at

ivanlio manis.ai. And then if you're

interested in joining the manis team, we

are hiring uh right now. Um and so feel

free to reach out to me or just chat

with me here. I'm happy to take any

questions about the API. And um thanks

so much for taking the time to listen to

this. I'm curious how you think about

educating people about all the possible

use cases for the API and how to stitch

all these things together to solve their

problems because I imagine a lot of this

is new to people and it doesn't quite

click immediately that oh I could use

the mass API to solve my problems.

>> Yeah, I think the easiest way to get

started before you move to the API is

actually to play with our web app

because the web app has everything

nicely set up. you know, you don't need

to do web hooks, you don't do

integration. And so a lot of times what

I'll recommend doing is saying, hey, I

have a problem or something I'm

repeatedly doing. Um, you look at the

basically the web app, you try a few

times and manage can get it done pretty

well and then you want to start looking

at the API, testing a bunch of these

requests, seeing how what you need to

provide, what sort of context, and then

getting that nailed down consistently.

Um, I think the that's how I would

approach it. Uh, so use a really simple

way, a simple sandbox, and you use that

to basically get started. Yeah.

Um, is there any other questions that I

can help with?

>> No, you can go ahead.

>> So, so no question on the API, but can

you tell us very quickly how you created

that site? What were the steps the the

conference site? You redid that, right?

>> I actually So, if you can talk a little

bit about that. Uh,

>> sure. I can show the manage chat

actually. I think that's more fun. Um,

script.

Yeah, let's give it a while for this

site to load, I think. Uh, so we can see

like this is basically the full chat

that's running. It'll take a while to

load because there's quite a lot of

conversations that need to be loaded up.

But basically what I did is I just said

like hey can you start with this? Can

you scrape all the events? There should

be like 70 plus talks. I think the time

is on like EST. Can you build a website

that's like clean brutalist design

search bar at the top like add to

calendar I mean star events and make it

work on mobile too. And actually I tried

to use like a bunch

man has a lot of cute like emojis but I

tried to use a lot of these different

like services like mix bread for a while

and then I looked at chroma and then it

just gave you like API key. But really

what you can see over here is that this

is a iterative process where you're

using manners as a way to basically

handle a lot of these complex edge cases

that a simple agent that might work out

of the box for simple websites might not

be able to do, right? And so

after I gave it like set of events, you

can see like manage just wrote a simple

Python script. It converted all of the

individual PM am stuff whatnot and it

just converted all to UTC and then it

just scraped everything in the end. And

one of the things that was really cool

that I saw was just that um if you look

at the page uh it kind of tried to

expand

scrolling scrolling really far. Yeah. So

basically ran a lot of JavaScript. It

tried to match like what it expanded. It

read the HTML and then from there it was

able to actually get the right set of

events. And so I think over here you can

see it's very specific use case I had in

mind. I want to make sense of events. Um

and I think the best way to work with a

lot of these is just to have just try

see what the manage agent can do and

then thereafter like try to put it

together. Yeah.

>> Go ahead. You can ask.

Uh so thanks Ivan amazing demo and

thanks for such a tidy and clean

notebook. Uh I'm going to go back and

try it straight away in my own company

because like I've been meaning to do

support agents and this is an amazing

demo. I just wanted to ask uh where does

all this information because all so

sensitive where does it live and can we

like get it deleted later or anything

like that?

>> Sorry. What do you mean by what is this?

>> Oh like right now who's reading my

transcripts? Oh,

>> I think like when it comes to if you say

like who's reading a transcript, you

mean like all these chats?

>> Yeah.

>> So like user privacy is really important

for us and so for us like we can't read

any of the chats. Yeah. The only chats

we read are when you share about hey man

this isn't working and then we go in and

check it out. Um I think all of your

data is housed in the US and so there's

no sort of like worry about that. Yeah.

>> Start with that. Sure.

All right. So, I know you built this

really cool page. What would be really

cool like if you could have those events

like put it in directly into your

calendar? So, and also my another

question was like like what's the most

interesting use case you have seen the

manus people using the manus API or just

the platform

>> API is pretty new. So, I think we're

sort of like exploring and seeing what

people are using it for. a lot of people

are using it for research trying to like

really access a lot of like to make

sense of a lot of data and I think like

that is basically like leaning a lot of

the advantages that manis has um in

terms of the sort of advantages that

manis I think like the cool things um I

really like pickle ball I don't know if

anyone here plays it but it's like

pretty popular but it's really

competitive in Singapore to basically

get like pickle ball slots and you can

only book them through the government

it's a Singapore thing and so what I got

managed to do is I wrote like a Python

script that spun up like six selenium

instances and it scraped like the entire

government website and then they said

like in two weeks you could play pickle

ball at this location and and I thought

that was pretty cool because I think

that's one of the benefits you get by

using an general agent with it own

sandbox with it own ability to basically

spin up these like code to run it to

test it um and if you use the API that's

what you get out of the box yeah

>> is it possible to use the my browser

through the API and if so how would it

determine which browser to

Yeah, I think um when it comes to my

browser, I think um that will be uh

something that we'll look into. So

because my browser requires you not only

choose the browser but also approve it

because you don't want to randomly spin

up tabs on your browser. Um so we'll be

working on basically improving the

permission system. So you can do things

like the um like why research um the

browser and all these other bits of

things that you need to authorize. um

because user permissions is something

that we want to try to think carefully

about and so we want to make sure we

have it done well before we ship it out

but that's in the road map soon. Uh we

also have um in a maybe two weeks um

you'll be able to let's say manis

generates like a markdown or manage

generates like slides for you they will

all be able to be converted to the same

form as you see on the UI. So what this

means is that let's say you give mana

say hey I'm really interested I would

like to pitch my company I would like to

pitch something to someone right who

does all the research puts slides

together and using the same API you can

download a full PvPX file you can export

it however you want as a PDF I think

that's really useful or even like

markdown to PDF and so we have a lot of

these same uh requ um features in mind

to ensure feature parity um so that you

get essentially the same experience on

the API and the UI. Yeah,

>> that was really informative. Thanks very

much. So my question is about like uh so

if I'm doing some research on some

topics, I don't want always to like give

it like the background, the context um

in every conversation since it's linked

to like uh you know my accounts API

keys. Um my question was um if it's

possible to like remember it's you know

me have like a memory or like for me to

decide like in every conversation do I

want to you know remember um you know

just draw memory from like my other

conversations or um you know like a

temporary mode stuff like that.

>> Yeah, I think a memory is something

that's really interesting. Uh it's

something that we're actively looking

at. Um and so I think for now it's not

possible but maybe in the near future.

So, for now, you have to be a bit more

explicit when working with Mattis,

unfortunately. Yeah. Um, are there any

other questions I can help with?

Uh, cool. If not, then uh I'll just be