DEV Community: Lolo Code

Build a Serverless Discord Bot with OpenAI GPT-3 in Minutes using Template Functions in Lolo

Lolo Code — Tue, 31 Jan 2023 12:43:49 +0000

Leverage the Low Code part of Lolo Code to build a Discord Bot that will be able to receive messages and respond to messages with OpenAI’s GPT-3 in a few minutes.

This article is a response to a user that wanted us to show how to quickly build a Serverless Discord bot that will be able to handle and create messages using OpenAI’s GPT-3. We’ll be using a library function we’ve set up so there will be minimal code involved here. You’ll be able to customize intents and partials as you wish though, by configuring the Discord Socket function in Lolo.

See the Lolo workflow below.

The process will be about 5 or so minutes. Let’s start.

Create your Discord Bot

Get started by going to https://discord.com/developers/applications and creating a new application. You’ll need have a Discord Server before doing this, so do create one if you don’t have one yet.

Go to the Bot tab and click ´Create a bot´. Once your bot has been created, you’ll need to set some Privileged Gateway Intents by scrolling downwards.

After you’ve saved do Reset Token and then save your token somewhere safe. We’ll need it in a bit.

Now navigate to OAuth2 and then URL Generator. Set Bot under Scope and then Send Messages and then Read Messages/View Channels as Bot Permissions.

Copy the URL that has been generated for you at the bottom. Paste it into your browser. This is how you’ll authorize your application.

Great. We’re done here.

Create an Application & add the Discord Socket

Go to Lolo Code and create a new application. You can create a free account on the same page if you don’t have an account.

You can name the application whatever you want.

Once you have an empty graph in front of you, go to the Library Function’s menu to the left. Look for Discord Socket there and add it once you find it.

You always open up functions by double clicking them. The Discord Socket needs to be configured with the token we got earlier.

We also need to set Operation → Messages.

To be able to read DMs to the bot we need to set some Intents and Partials as well. Set DirectMessages, GuildMessages and MessageContent as Intents. You can set Guilds as well. Make sure you also set Channel as Partials. See our config below.

What you set here dictates the messages your socket will receive from Discord. You can read up on Intents here and Partials here.

Process Incoming Messages from Discord

Now that we’ve set up the Discord socket we’ll receive messages depending on the intents we set. For this one, we’ll receive messages from any channel.

Depending on what messages you would like to respond to you may want to first just log the data the message comes with in a new function.

So, create a new function and paste in this code into it.

exports.handler = async(ev, ctx) => {
  const { log } = ctx;

  // you'll have access to the client as well as the interaction in the event object
  log.info("incoming event data: ", JSON.stringify(ev.interaction))

};

This code will log the interaction data to the Logs in your Lolo application.

You can connect the Discord Socket to the new function now and then Save → Configure → Advanced Settings → Set Node V.16 → Update. This should deploy your application with Node version 16.

See the clip below on how we do this.

Please wait up to a minute before you see your Logs coming in when you first deploy with new dependencies.

Once it has been deployed, you can write something in a private message to your bot in Discord and see the event come in in your Logs in Lolo.

You may want to look into this event data to see what you want to filter with. I will be filtering out messages that are coming from this channelid and then I will filter out any messages made by the bot itself. I.e. I only want the message that comes from a direct DM and is not made by the bot itself.

So open up the new function again, remove the previous code and paste in this code. You will have to tweak two values in it, as you need to set the your own channelId and authorId.

exports.handler = async(ev, ctx) => {
  const { route, log } = ctx;

  // you'll have access to the client as well as the interaction in the event object
  log.info("incoming event data: ", JSON.stringify(ev.interaction))

  // parse interaction data to extract channel and author
  const interaction = JSON.parse(JSON.stringify(ev.interaction));

  // filter the message - in this case the channelID of the DM and do not respond if author is bot with this id
  // REMEMBER TO CHANGE IDS
  if(interaction.channelId === 'CHANNELID HERE' && interaction.authorId !== 'BOT AUTHOR ID HERE') {
    ev.message = interaction.content;
    route(ev, 'out')
  }

};

I have already logged a message from the bot to get that interaction.authorId but you may want to start only with filtering interaction.channelid and some other identifier. You have access to the message content itself in interaction.content that you can use instead.

Let’s make an API call to OpenAI now.

Make an OpenAI API Call with the Message

If you look at the above code, we’re setting ev.message with the text content here when the message passes that if statement. We’ll use this in the next function now.

Open up your Library Function’s menu again and look for Lolo/OpenAI Completions. Once you find it, click it to add it on. Open it up to configure it.

We’ll need an API key here for this. So go get it in your OpenAI account. If you don’t have an account yet, do create one and then create a new key here.

Set prompt as {event.message} and then the model as text-davinci-003. Also set some additional options, temperature as 0.3 and max_tokens as 1500. Tick in the Store Prompt History, if you want a feeling of a conversation with your bot. This is optional.

You may tweak this as you’d like. It is simply making an API call. However, you don’t want to use too high of a value for max_tokens or you may end up with 400 errors.

We’re done here so we can set up the response we’ll send back to Discord now in another new function.

Reply to the Message with the OpenAI Response

Go back to your graph and create another new function.

Paste in this code into its code handler.

exports.handler = async(ev) => {
  // OpenAI response
  const aiResponse = ev.response.data.choices[0].text;

  // respond to discord message
  ev.interaction.reply(aiResponse);
};

Rename it Reply and remove the out port.

Remember to connect all your functions with the correct ports. See the finished workflow below.

Save your application. Now go to configure instead of Run, and set Node version 16 under Advanced Settings. After this click Update. This will run your application with node version 16.

You shouldn’t have to pick node version each time, we’re fixing this with the new IDE for the future. But, unfortunately you’ll have to set this each time you re-deploy as it is now.

Wait about a minutes to see your Logs come in. It should log ‘bot live’ when it is running.

Test your GPT-3 AI Discord Bot

Now go back to Discord and DM your bot with some message to test it out.

The result should look like the conversation below.

Try out whatever with it. We haven’t tested everything yet and it goes without saying you should be able to do more advanced stuff with this.

Join us in discord to talk with others or get help from the team.

❤ Lolo

Create a Free WhatsApp Binance Bot in a Few Minutes with Serverless in Lolo

Lolo Code — Tue, 31 Jan 2023 12:19:39 +0000

For anyone keen to set up their own WhatsApp bots and stream real-time cryptocurrency data from Binance in a few minutes with minimal code with a Serverless app.

For this article we’ll help you go through the entire process of setting up a Facebook app that allows a bot user to receive and send messages. Then we’re setting up a Lolo application (i.e. a Serverless event-driven app) to receive and send messages to WhatsApp via a few triggers (library functions).

We’re also learning how to quickly set up a Binance data stream to get continuous updates on btc. You can choose which cryptocurrency you’d like. You’ll also be able to chose any trade steam. This is just a demo for something simple. We thank Jesper on our team for setting most of this up so it will go smoothly.

The process will look like this.

Get Credentials from Facebook
Create a Lolo Application
Configure Webhooks
Process Messages
Set up a Binance stream to receive price updates for BTC
Send back a reply to WhatsApp

Facebook or Meta does make us jump through a few hoops for credentials here but once you’ve set this up once it will be easier the next time. And isn’t learning how to create WhatsApp bots pretty essential?

Get Credentials from Meta for WhatsApp

Log into developer.facebook and create a new app. If you don’t have a developer account do open one.

Go to settings → basic to get your app secret.

We’re done here for now but do keep the tab open because we’re coming back to set up a webhook in a bit.

Create a Lolo Application to set up a Webhook

Create a new application in Lolo Code. You can create a free account on the same page if Lolo is new to you.

Add the Lolo/WhatsApp Trigger to your application.

Save and Run your application.

Go to docs to find your callback url as we’ll need it in a bit.

Configure Webhooks in Facebook to Create a WhatsApp Bot that can Receive Messages

Go back to Facebook’s developer dashboard and find Products → webhooks.

Choose WhatsApp Business Account and then click ”subscribe to this object.” Here you’ll paste in your callback url that we got from Lolo as well as the verification string we put into our WhatsApp trigger in Lolo, i.e. itisme.

Once you’re done you should see choices to subscribe to, what you’re looking for is Messages. Click subscribe.

Now navigate to Get Started under WhatsApp just under Webhooks, here you’ll need to add your phone number of your WhatsApp account. You’ll get a verification code to your whatsApp account to verify it.

You’ll also want to save the phone number that Facebook gives you as well, because it’ll be your bot’s number.

Process Messages Coming From WhatsApp

If you try to message the number of our new bot we’ll get a payload from Whatsapp with something like the JSON below. Right now we’re not logging anything in the Lolo app but just to demonstrate what the payload will look like.

{
  "from":"",
  "id":"",
  "timestamp":"1671457845",
  "text": { 
    "body":"incoming text here" 
  },
  "type":"text"
}

So to access the text of the message in a connecting node via the event (ev) object that is accessible in the event handler we would use ev.text.body. To do this, create a new raw function in your Lolo app.

Double click it to change its code. We get a bunch of default code in the handler that we need to replace. Right now it would just be logging the event object to the Logs. So, remove the default text and copy the text below to paste it into its handler.

exports.handler = async(ev, ctx) => {
  const { route, log } = ctx;

  // access text of whatsapp payload
  log.info(ev.text.body)

  // route the messages to the right port
  if (ev.text && ev.text.body === 'btc') {
    route(ev, 'btc');
    return;
  }
};

Here we are setting the naming to btc (as we will be checking Bitcoin pricing) but you can change this later.

As you can see in the code above, we are routing the message to btc here. To route this to a port called btc, we need to create it. So, go to the Settings and then look for the tab called Ports.

We can also rename the function to Handle Messages and connect the two nodes.

What we’ve done so far is to set up a webhook that we’ve given Facebook so it will be triggered when a WhatsApp message comes in via the Bot’s number. When a message is sent to this number, the Lolo app will recieve an event with a payload of data. We then process the message by accessing ev.text.body in another node to see if the message is equal to btc and if so we’ll route the message further via the outport btc.

Now we’ll start streaming Binance data.

Set up a Binance Stream to Receive Price Updates for BTC

Go look for the Lolo/Binance Trigger in your menu palette, it should be available there.

Click it to add it to your application and then double click it to configure it. It may take 20 seconds for the params to show so do wait for them.

Configuring the trigger is real easy. Just select the kind of data stream you’re interested in. Depending on the stream some additional data might be required, but all options are just simple drop down menus.

In this case we’re interested in the ticker for the price of Bitcoin in USD.

More information about what streams are available and what they contain can be found in the Binance docs.

Now you have created a data stream with BTC pricing, this will produce an event every second. You can log the event in another function to see the events being produced but we’ll skip that here.

You can probably think of other things to do with this I imagine. Maybe setting up a an if statement that looks for abnormalities and then pushes a message to WhatsApp when the price falls below or above your given thresholds. This would be easier than this article.

In any case, we’re doing something different here.

Get Current BTC Price When the WhatsApp Message Comes Through

Right, so when we ask for btc in WhatsApp we need to somehow get the current price that has been streamed by the Binance trigger. So, we need a way to store the latest price so that we can retrieve it when the btc command is received.

To do this we add another raw function in the bottom right corner. Remove the default code in its handler and insert the code below.

let latest_price = undefined;

exports.handler = async(ev, ctx) => {
  if (ctx.input === 'update') {
    latest_price = ev.c;
  } else if (ctx.input === 'get') {
    ctx.route({ev, latest_price});
  }
};

The above lines of code stores the price in the latest_price variable if the incoming port is update (i.e. comes from the streaming Binance data trigger), and if the port coming in is get (i.e. comes from the WhatsApp event), it routes the latest_price that the variable has stored to the out port.

For this function we then need two input ports (update & get) and one output port. To configure ports for a function navigate to Settings and then to the Ports tab. Look below on what this should look like.

You can rename the function to Store as well.

If this is confusing, just keep going. It’ll be less so once you’re done.

We also need to connect the right ports. Remember when an event is hit data flows from one node to another via the ports. So make sure your ports are connected like the picture below.

The get port should be connected to Handle Messages (coming from WhatsApp) and the update port should be connected to the Binance Stream Trigger.

Craft a Reply to Send to WhatsApp
Now we need to send back a reply to the WhatsApp message but first we need to just structure the event object correctly to be proccessed by the library function.

You can probably do this in the function above but let’s do it separately.

Create a new additional function in Lolo, remove the default code and paste in the code below into its handler.

exports.handler = async({latest_price, ev: {from}}, ctx) => {
  ctx.route({to: from, text: `The latest price of BTC is \$${latest_price}.`});
};

This code is setting up the event object so it can be processed by the WhatsApp Send function in a bit. It’s another library function like the Binance Trigger and has been set up by Lolo so it’ll be easy to use.

Rename the function to Reply. You can connect it to the Store function’s output port as well.

The last thing we have to do now is send a message back to WhatsApp.

Send Back BTC Pricing to WhatsApp

Search for another function called Lolo/WhatsApp Send in your Lolo Application.

Once you’ve found it, you can add it to your application. Double click it to configure it.

Here we need to add a few things. And here is also where you need to spend a bit more time as Meta is difficult about sending messages to WhatsApp so we’ll need a few more credentials.

Go back to your Facebook Dashboard and navigate to WhatsApp again and then Getting Started. Here you can find your Phone Number ID. Remember it is the phone number ID we’re looking for and not phone number.

You can paste that ID into the second input.

For getting a META access token we’ll have to go through a few more hoops. The reason is that META would like you to create a so called system user with correct privileges. But you only have to do this once, after this you can use this bot user for other things.

To create a system user, go to business.facebook.com. You should land on a page that looks like this. For you this will be a personal account, for us it the our Lolo Business account. We never really use Facebook but we do have an account there hehe.

Press the Settings button and then find Business Settings to press that too.

This should bring you to a page like this where you can add system users.

You can click Add and then name the user whatever you’d like. Choose Employee as well.

When it has been generated for you, click Add Assets. Then go to Apps, choose your App where you’ve set up WhatsApp and then tick Access to Develop app.

Hit save. Now the our created system user need to be given access to the WhatsApp account. To do that, in business settings, navigate to Accounts → WhatsApp-Account.

Click the add people button. A dialog pops up. Select the system user, and toggle partial access.

Hit save.

We now need to generate an access token for this system user. Go back to the page system users settings page and click Generate Token.

A dialog will pop up asking you to choose an app. Once you’ve choosen your app you will have to set Permissions. We are looking for whatsapp_business_messaging.

Scroll down the bottom of the dialog and hit the button that says generate. You’ll see a new dialog with the generated token. We finally got it!

Go back to your Lolo app and paste in the token in the Lolo/WhatsApp Send node.

Test it Out

Use the phone number we got from the Facebook App and then send it btc it should send you back the current Bitcoin price.

It goes without saying that you can create more complex stuff than this. It is just a demo of the WhatsApp and Binance Library Functions we got available.

❤ Lolo

Create a free OpenAI GPT-3 Bot to Have Someone to Talk to at Work via a Slack app with Serverless

Lolo Code — Thu, 08 Dec 2022 16:10:08 +0000

OpenAI invites everyone to test ChatGPT, a new AI-powered chatbot so let’s use it to quickly build a Slack app to communicate with it for free. Yes, we created a library function for this so it’ll be quick and you won't need that much programming skills for this.

Check out a preview of the finished work below.

To go through the steps required to do this.

We need to create a new Slack app and enable slash commands (I’ve picked /talkhere as you can see in the screen above.
When this command is called via Slack we will call OpenAI via a library function in Lolo. You’ll be able to set temperature and max tokens if you want.
Then we’ll route this data to Slack via another Library function in Lolo allowing us to override the message with the OpenAI answer.

The result will be an answer in Slack from OpenAI based on our prompt.

Check out our serverless Lolo app below as well.

You have 18$ worth of free tokens in OpenAI that you can use, and that will last a long time. The Lolo app is free. Creating a Slack bot in Slack is free as well so no need to pay anything for this to work.

We tested a bunch of things, cleaning up code, doing translations, basic questions, talking to it, creating python code, correcting messages. You name it.

Getting an OpenAI API Key

You’ll need an OpenAI API key, that you can quickly get just signing up here. Then navigate to API Keys to create a new key. Save the key somewhere, we’ll need it.

Setting up a Lolo Application

Create a Lolo account here if you don’t have one already. Otherwise, create a new app and then find a HTTP trigger in the menu to the left of the graph.

Add it to your application and then make sure to set a path and rename it to Slack Webhook.

Psst! We forgot to show this but you should also set method to POST and not GET. Slack will send us a POST request, so if you don’t have the method set to post it won’t work.

Navigate to the HTTP trigger again to copy the external url, we’ll need it in a bit when we set up our Slack command.

We’ll also set up to send back the required Slack response within 3 seconds in another node right away. So, create a new function in the bottom right corner and add this code block in there.

exports.handler = async(ev, ctx) => {
  const { route, emit } = ctx;

  // Emit response right away to Slack
  emit('response', { statusCode: '200'});

  ev.responseURL = ev.body.response_url;
  ev.message = ev.body.text;

  // route the event object to the next node
  route(ev);
};

You’ll see in the code above that we are also getting the responseURL from the payload. We’ll need this one later to send back a message to Slack.

We’re also collecting the message that we’ll use as the prompt when calling OpenAI and setting it to the event object (so it can be used in another node later).

Now let’s create a Slack app so we can use this webhook we’ve set up.

Creating a Slack Application

Go here and then press create new app. Unless you want to use an already existing application.

Then navigate to slash commands, and create a new command. You can name it whatever you want but you need to set the external URL that we got from Lolo as the request URL. Slack will send a post request to it when it is hit so we can process that request (make the OpenAI call and so on).

After this make sure to install your application to your workspace.

We’re done here now so let’s make the OpenAI API call.

Calling OpenAI with the Slack Message as the Prompt

Now we’re heading back to the Lolo app and looking for the Lolo/OpenAI library function in the palette. Where you found the first HTTP trigger.

Open it up to set the required values. Use the OpenAI API key that we got earlier. You can create another one if you’ve lost the first one.

Here we’ve set temperature as 0.3 which seems to be the amount of creativity you want it to answer with. We’ve also set max_tokens to 4000 so the message doesn’t get cut off. You can several more options to set here but make sure you use the right wording for them. For the first time use these two options or none at all, after that you can fine tune it as you want.

The model is set to davinci which is the more expensive one, you can change this to ada or so. The prompt is set to a dynamic value from the event object that we have access to in each node. Remember that we set ev.message to the text we received from the Slack payload earlier.

That is it here. Go back to your graph.

Send back a Message to Slack with the Response URL

Now we need to look for the Slack library function to send back the response. So again open up the function palette in your graph in Lolo and add the Slack Msg (beta) from the list.

Open it up to configure it. We need to set operation to Slack Response.

We’ll need to configure this one with a bit of dynamic values here. We have the response url set to the event object and OpenAI will give us back the response in {event.response} so to access the text of the response we will need to set {event.response.data.choices[0].text}

See the exact values you want to set below.

To understand this, we are getting a payload with the Slack slash command and then saving the response url so we can send an HTTP request to it when we are ready (i.e. when we’ve made the OpenAI request and gotten back the correct data). This library function does this for us though but it does need somewhere to post to, i.e. to this response url.

We’re done here so we can go back and make sure to connect all the nodes now and then Save and Run your application.

Go to your Logs to see things happen in your Lolo app. To make sure it has been deployed, look for “Listen to port 4000.” Do wait at least a minute.

Now we can test it out. Go to Slack and try out your command with some text you want to ask OpenAI.

Try out whatever with it. We haven’t tested everything yet and it goes without saying you should be able to do more advanced stuff with this.

❤ Lolo

Build a Serverless WebSocket Application in 5 minutes with Lolo

Lolo Code — Mon, 05 Sep 2022 14:19:53 +0000

Originally published here.

WebSockets are mainly used to create real-time applications, such as chat apps, collaboration platforms and streaming dashboards. These applications take advantage of two-way/bidirectional communication between a server and users’ browsers.

Serverless is usually associated with FaaS, an isolated stateless function that is triggered by another service. Creating a Serverless Websocket application would require you to use AWS Lambda with WebSockets in API Gateway and DynamoDB to store connections. This is overly complicated.

We’ll show you how to create something faster. Serverless iFaaS platforms don’t require initialization before the function executes so you don’t pay a price for waking up a container once it has been deployed. It’s technically always live. You also have access to a baked in key / value store which means that you don’t end up loosing state between subsequent invocations. I.e. you don’t have to start from a blank slate on every invocation. Hence the lack of need for an external database such as DynamoDB.

The Plan

We’ll demonstrate something very simple here by using a pre-made Websocket Trigger to connect and broadcast all messages to all connected clients. See the visual workflow below. You’ll need a free Lolo account to set this up yourself.

If you want to get started right away you can simply copy the contents of this document and paste it into a new application in a blank graph in Lolo. Save and Run the application to deploy it. That’s 1 minute of work.

Do follow along though if you want to understand how to use it or if you want to set this up from scratch.

Create an Application and add a Trigger

To begin, we need to set up a new WebSocket server that can handle inbound WebSocket requests from clients.

We do this by first creating a new application in your Lolo account and then adding the Lolo/Websocket Trigger from the Functions Gallery on the left of the graph. Add in a path name, such as /socket. You can also rename it.

Process the Incoming Request

When you add this WebSocket Trigger you get three output ports in the node called req, message and close so you need to setup ways to process these requests. Add another inline Function (i.e. a custom function) and name it ‘Process Request.’ Remove the in port and instead add in three in ports called req, msg and close.

Link the ports to the right in and out ports with the nodes, look below for an illustration on how to do this.

We need a bit of code to do something here with the WebSocket connection. Copy and paste in the code from below. Open up the Process Request node and paste in the code below in the handler.

const connections = {};

exports.handler = async (ev, ctx) => {
  const { route, input, inputs, log, emit } = ctx;
  const { sessionId } = ev;

  // check incoming port (i.e. req, message or close)
  switch (input) {

    // on first connection
    case inputs.req:
      connections[sessionId] = {
        send: body => emit('response', { body }),
        end: () => emit('response', { end: true }),
        info: ev.headers
      }
      ev.body = { connected: true, yourConnectionId: sessionId };
      // re-route data to 'req' output port
      route(ev, 'req');
      break;

    // on subsequent messages 
    case inputs.msg:
      // re-route data to 'msg' output port
      route({ connections, message: ev.message, sessionId }, 'msg')
      break;

    // when client disconnects 
    case inputs.close:
      log.info("client has disconnected");
      delete connections[sessionId];
      break;
  }
};

The code above is checking what ports the incoming data is routed through, giving us a way to handle a new connection by adding it to connections. We are also setting up how we want to handle subsequent messages and a disconnecting client by using the in ports, msg and close.

This code above though is re-routing to other nodes via the route() method as well. As you can see we have two output routes here to ‘req’ and ‘msg.’ We thus need to add those two output ports as well.

Send back a response

Now we have two outports in the Process Request Function that needs to go somewhere, so we create another inline Function called Affirm Connection and paste in the code below.

All this does is signal the listener within the WebSocket Trigger to send a response to the client. We will route the req route to this node.

exports.handler = async(ev, ctx) => {
  const { emit, log } = ctx;
  // Log to the console that a client has connected
  log.info("client has connected");
  // send response to the client
  emit('response', ev);
};

Along with this we also need a way to handle subsequent messages. In this case we said we would broadcast all messages to all clients when someone sends something. So, create another inline Function (i.e. a custom function) and call it Handle Messages. Paste in the code below, see comments to understand what it does.

exports.handler = async (ev, ctx) => {
  // extract connections, and current session id from the event data
  const { connections, sessionId } = ev;
  // send messages
  await broadcastToAll(ctx, connections, sessionId, ev);
};

const broadcastToAll = async ({ log }, connections, currentSessionId, ev) => {

  // loop through connections
  Object.keys(connections).forEach(sessionId => {
    try {
        // send message to everyone but the current sessionId
        if (currentSessionId !== sessionId) {
        connections[sessionId].send(`${sessionId} says: ${ev.message}`)
        } 
    } catch (e) {
      log.error(e)
    }
  })

};

You can remove the out ports for both of these new Functions. Now we also have to route the data visually from the Process Request node to the other two nodes we’ve created.

See these steps in action below.

Save and Deploy

Alright, that was it. You can save and deploy.

Look in the Logs for the ‘Listening to port 4000’ message to see if it is ready to use. This may take awhile. We are not using any NPM modules here so should be faster but if we did we would have to wait about a minute.

Now go into the WebSocket Trigger to collect the External URL. We are going to use it to connect to this Websocket.

Open two terminals on your computer and then connect via wscat.

wscat -c wss://eu-1.lolo.co/:appId/socket

Remember to NPM install wscat -g (via your terminal) first if you don’t already have wscat installed.

Now you should be able to talk via the different terminals. You can ask a friend to connect on a different computer and talk that way.

It goes without saying that you can connect this via a frontend to build a quick chat app.

Remember if you are having issues, just copy the contents of this document and paste it into an empty graph in a Lolo application to get the entire app set up for you.

Let us know if you have any feedback. We’re keen to create a better Serverless experience.