Building Intelligent Research Agents with Manus - Ivan Leo, Manus AI (now Meta Superintelligence)

Channel: aiDotEngineer

Published at: 2025-12-30

YouTube video id: xz0-brt56L8

Source: https://www.youtube.com/watch?v=xz0-brt56L8

[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.
[clears throat] 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 [clears throat] 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.
[clears throat]
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.
[clears throat] 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 [clears throat] 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. [snorts] 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
[cough]
[clears throat]
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.
[laughter]
That's a bit stressful. Okay, guys.
Please be nice to my end point.
[clears throat] 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,
[clears throat] 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.
>> [clears throat]
>> 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,
[clears throat]
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.
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.
[clears throat]
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
over here at the front. Uh, we also have
another colleague from Manis Y over
there. If you need like any help with
API with the API or just asking
questions on manis in general. Uh, thank
you so much for taking the time to
listen [music] to me today and sorry
about the technical difficulties.
>> [music]
>> Heat.