Anaiya Raisinghani

Associate Developer Advocate

Partner

Guru Kamat

Co-Founder & CTO @ Neurelo

Ready to hit the ground running with less code, fewer database complexities, and easier platform integration? Then this tutorial on navigating the intersection between Neurelo and MongoDB Atlas is for you. 

[Neurelo](https://www.neurelo.com/) is a platform that utilizes AI, APIs, and the power of the cloud to help developers better interact with and manipulate their data that is stored in either MongoDB, PostgreSQL, or MySQL. This straightforward approach to data programming allows developers to work with their data from their applications, improving scalability and efficiency, while ensuring full transparency. The tutorial below will show readers how to properly set up a Neurelo account, how to connect it with their MongoDB Atlas account, how to use Neurelo’s API Playground to manipulate a collection, and how to create complex queries using Neurelo’s AI Assist feature. 

Let’s get started! 

### Prerequisites for success

 - A [MongoDB Atlas account](https://www.mongodb.com/cloud/atlas/register)
 - A [MongoDB Atlas cluster](https://www.mongodb.com/basics/clusters/mongodb-cluster-setup)
 - A [Neurelo](https://dashboard.neurelo.com/register) account

## The set-up
### Step 1: MongoDB Atlas Cluster

Our first step is to make sure we have a MongoDB Atlas cluster ready — if needed, learn more about [how to create a cluster](https://www.mongodb.com/basics/clusters/mongodb-cluster-setup). Please ensure you have a memorable username and password, and that you have the proper network permissions in place. To make things easier, you can use `0.0.0.0` as the IP address, but please note that it’s not recommended for production or if you have sensitive information in your cluster. 

Once the cluster is set up, load in the MongoDB sample data. This is important because we will be using the `sample_restaurants` database and the `restaurants` collection. Once the cluster is set up, let’s create our Neurelo account if not already created. 

### Step 2: Neurelo account creation and project initialization

Access [Neurelo’s dashboard](https://dashboard.neurelo.com/) and follow the instructions to create an account. Once finished, you will see this home screen. 

![Neurelo home screen](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt659719c3f8a67be6/65c3f27225aa940062350cac/Screenshot_2024-02-07_at_4.12.30_PM.png)

Initialize a new project by clicking the orange “New” button in the middle of the screen. Fill in each section of the pop-up. 

The `Organization` name is automatically filled for you but please pick a unique name for your project, select the `Database Engine` to be used (we are using MongoDB), select the language necessary for your project (this is optional since we are not using a language for this tutorial), and then fill in a description for future you or team members to know what’s going on (also an optional step).

![Project screen in Neurelo](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta8d40f74c679843f/65c3f2ef0acbc57800110c1a/Screenshot_2024-02-07_at_4.15.16_PM.png)

Once you click the orange “Create” button, you’ll be shown the three options in the screenshot below. It’s encouraged for new Neurelo users to click on the “Quick Start” option. The other two options are there for you to explore once you’re no longer a novice. 

![Screenshot with options to start your Neurelo journey](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt2f4929b0b9d962fc/65c3f33955479848e480a68c/Screenshot_2024-02-07_at_4.16.25_PM.png)

You’ll be taken to this quick start. Follow the steps [through](https://docs.neurelo.com/getting-started/starting-your-neurelo-project).

![Screenshot with the Quick Start option](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4c27636930411755/65c3f382087222c3474973b0/Screenshot_2024-02-07_at_4.17.42_PM.png)

Click on “Connect Data Source.” Please go to your MongoDB Atlas cluster and copy the connection string to your cluster. When putting in your Connection String to Neurelo, you will need to specify the database you want to use at the end of the string. There is no need to specify which collection. 

Since we are using our `sample_restaurants` database for this example, we want to ensure it’s included in the Connection String. It’ll look something like this:

```
mongodb+srv://mongodb:<password>@cluster0.xh8qopq.mongodb.net/sample_restaurants
```

![Screenshot of where to put our data source](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt8a8a3ccf81a0ae60/65c3f3e6ce84ad7dcbe35ab7/Screenshot_2024-02-07_at_4.19.22_PM.png)
  
Once you’re done, click “Test Connection.” If you’re unable to connect, please go into MongoDB Atlas’ Network permissions and copy in the two IP addresses on the `New Data Source` screen as it might be a network error. Once “Test Connection” is successful, hit “Submit.” 

Now, click on the orange “New Environment” button. In Neurelo, [environments](https://docs.neurelo.com/getting-started/starting-your-neurelo-project/step-3-create-an-environment) are used so developers can run their APIs (auto-generated and using custom queries) against their data. Please fill in the fields.

![Screenshot of an environment in Neurelo](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt2e7a71c770f0e4ac/65c3f49317201aae374acb8e/Screenshot_2024-02-07_at_4.22.16_PM.png)
  
Once your environment is successfully created, it’ll turn green and you can continue on to creating your [Access Token](https://docs.neurelo.com/getting-started/starting-your-neurelo-project/step-4-create-an-access-token). Click the orange “New Access Token” button. These tokens grant the users permission to access the APIs for a specific environment. 

![Screenshot of creating an Access Token](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6562a5e8eced6378/65c3f4df0acbc57a45110c32/Screenshot_2024-02-07_at_4.23.32_PM.png)

Store your key somewhere safe — if you lose it, you’ll need to generate a new one. 

The last step is to activate the [runners](https://docs.neurelo.com/getting-started/starting-your-neurelo-project/step-5-start-runners) by clicking the button. 

And congratulations! You have successfully created a project in Neurelo. 

### Step 3: Filtering data using the Neurelo Playground

Now we can play around with the documents in our MongoDB collection and actually filter through them using the Playground.

In your API Playground “Headers” area, please include your Token Key in the `X-API-KEY` header. This makes it so you’re properly connected to the correct environment. 

![Where to put API Key to access the playground](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt7c5e00fe1375623c/65c3f54f90c22c1ffcd0578f/Screenshot_2024-02-07_at_4.25.19_PM.png)

Now you can use Neurelo’s API playground to access the documents located in your MongoDB database. 

Let’s say we want to return multiple documents from our restaurant category. We want to return restaurants that are located in the borough of Brooklyn in New York and we want those restaurants that serve American cuisine. 

To utilize Neurelo’s API to find us five restaurants, we can click on the “GET Find many restaurants” tab in our “restaurants” collection in the sidebar, click on the `Parameters` header, and fill in our parameters as such:

```
select: {"id": true, "borough": true, "cuisine": true, "name": true}
```
```
filter: {"AND": [{"borough": {"equals": "Brooklyn"}, "cuisine": {"equals": "American"}}]}
```
```
take: 5
```

Your response should look something like this: 

```
{
 "data": [
   {
     "id": "5eb3d668b31de5d588f4292a",
     "borough": "Brooklyn",
     "cuisine": "American",
     "name": "Riviera Caterer"
   },
   {
     "id": "5eb3d668b31de5d588f42931",
     "borough": "Brooklyn",
     "cuisine": "American",
     "name": "Regina Caterers"
   },
   {
     "id": "5eb3d668b31de5d588f42934",
     "borough": "Brooklyn",
     "cuisine": "American",
     "name": "C & C Catering Service"
   },
   {
     "id": "5eb3d668b31de5d588f4293c",
     "borough": "Brooklyn",
     "cuisine": "American",
     "name": "The Movable Feast"
   },
   {
     "id": "5eb3d668b31de5d588f42949",
     "borough": "Brooklyn",
     "cuisine": "American",
     "name": "Mejlander & Mulgannon"
   }
 ]
}
```

As you can see from our output, the `select` feature maps to our MongoDB `$project` operator. We are choosing which fields from our document to show in our output. The `filter` feature mimics our `$match` operator and the `take` feature mimics our `$limit` operator. This is just one simple example, but the opportunities truly are endless. Once you become familiar with these APIs, you can use these APIs to build your applications with MongoDB. 

Neurelo truly allows developers to easily and quickly set up API calls so they can access and interact with their data. 

### Step 4: Complex queries in Neurelo

If we have a use case where Neurelo’s auto-generated endpoints do not give us the results we want, we can actually create complex queries very easily in Neurelo. We are able to create our own custom endpoints for more complex queries that are necessary to filter through the results we want. These queries can be aggregation queries, find queries, or any query that MongoDB supports depending on the use case. Let’s run through an example together.

Access your Neurelo “Home” page and click on the project “Test” we created earlier. Then, click on “Definitions” on the left-hand side of the screen and click on “Custom Queries.” 

![Custom queries in Neurelo](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt73d4f6244529d305/65c3f5d2b3cfc081d0e60b01/Screenshot_2024-02-07_at_4.27.34_PM.png)
 
Click on the orange “New” button in the middle of the screen to add a new custom query endpoint and once the screen pops up, come up with a unique name for your query. Mine is just “complexQuery.”

With Neurelo, you can actually use their AI Assist feature to help come up with the query you’re looking for. Built upon LLMs, AI Assist for complex queries can help you come up with the code you need. 

![Where to find Neurelo AI Assist](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3b026a915eeade82/65c3f60d49edef245a6a2db6/Screenshot_2024-02-07_at_4.28.34_PM.png)

Click on the multicolored “AI Assist” button on the top right-hand corner to bring up the AI Assist tab. 

Type in a prompt. Ours is:
“Please give me all restaurants that are in Brooklyn and are American cuisine.”

![The complex query shown by the AI Assistant](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt943cc76d3c9f4f58/65c3f64c90c22ce946d0579c/Screenshot_2024-02-07_at_4.29.36_PM.png)
  
You can also update the prompt to include the projections to be returned. Changing the prompt to 
“get me all restaurants that are in Brooklyn and serve the American cuisine and show me the name of the restaurant” will come up with something like:

![AI Assist](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta02e6750b1332b71/65c3f67e7998da63996b579b/Screenshot_2024-02-07_at_4.30.25_PM.png)

As you can see, AI Assist comes up with a valid complex query that we can build upon. This is incredibly helpful especially if we aren’t familiar with syntax or if we just don’t feel like scrolling through documentation. 

Edit the custom query to better help with your use case.

Click on the “Use This” button to import the query into your Custom Query box. Using the same example as before, we want to ensure we are able to see the name of the restaurant, the borough, and the cuisine. Here’s the updated version of this query:
```
{
 "find": "restaurants",
 "filter": {
   "borough": "Brooklyn",
   "cuisine": "American"
 },
 "projection": {
     "_id": 0,
     "name": 1,
     "borough": 1,
     "cuisine": 1
 }
}
```
Click the orange “Test Query” button, put in your Access Token, click on the environment approval button, and click run!

Your output will look like this: 
```
{
 "data": {
   "cursor": {
     "firstBatch": [
       {
         "borough": "Brooklyn",
         "cuisine": "American",
         "name": "Regina Caterers"
       },
       {
         "borough": "Brooklyn",
         "cuisine": "American",
         "name": "The Movable Feast"
       },
       {
         "borough": "Brooklyn",
         "cuisine": "American",
         "name": "Reben Luncheonette"
       },
       {
         "borough": "Brooklyn",
         "cuisine": "American",
         "name": "Cody'S Ale House Grill"
       },
       {
         "borough": "Brooklyn",
         "cuisine": "American",
         "name": "Narrows Coffee Shop"
       },
…

```
As you can see, you’ve successfully created a complex query that shows you the name of the restaurant, the borough, and the cuisine. You can now commit and deploy this as a custom endpoint in your Neurelo environment and call this API from your applications. Great job!

## To sum things up...
This tutorial has successfully taken you through how to create a Neurelo account, connect your MongoDB Atlas database to Neurelo, explore Neurelo’s API Playground, and even create complex queries using their AI Assistant function. Now that you’re familiar with the basics, you can always take things a step further and incorporate the above learnings in a new application. 

For help, Neurelo has tons of [documentation](https://docs.neurelo.com/), getting started [videos](https://docs.neurelo.com/how-to-videos), and information on their [APIs](https://docs.neurelo.com/neurelo-api-reference-rest). 

To learn more about [why](https://www.neurelo.com/post/simplifying-database-programming-with-neurelo) developers should use Neurelo, check out the hyper-linked resource, as well as this [article](https://www.infoworld.com/article/3712840/why-developers-should-put-the-database-first.html) produced by our very own Matt Asay.


New to Neurelo? Let’s dive in together. Learn the power of this platform through our in-depth tutorial which will take you from novice to expert in no time. 

How to Get Started With Neurelo and MongoDB

Ready to build a robust and efficient application that can quickly process real-time data, is capable of adapting to changing environments, and is fully customizable with seamless integration? 

The developer dream trifecta of MongoDB Atlas, Neurelo, and AWS Lambda will propel your cloud-based applications in ways you didn’t know were possible! With this lethal combination, you can build a huge variety of applications, like the restaurant locator we will build in this tutorial. 

This combination of platforms can help developers build scalable, cost-efficient, and performant serverless functions. Some huge benefits are that the Lambda functions used still remain stateless — data operations are now stateless API calls and there are no stateful connections opened with every [Lambda invocation when Neurelo is incorporated](https://www.neurelo.com/post/neurelo-bridges-the-divide-between-aws-lambda-and-databases) in the application. We also are enabling higher performance and lower costs as no execution (and billing) time is spent setting up or tearing down established connections. This also enables significantly higher concurrency of Lambda invocations, as we can leverage built-in connection pooling through Neurelo which allows for you to open fewer connections on your MongoDB instance. 

We will be going over how to properly set up the integration infrastructure to ensure you’re set up for success, and then we will dive into actually building our application. At the end, we will have a restaurant locator that we can use to search for restaurants that fit our desired criteria. Let’s get started! 

## Pre-reqs

 - [MongoDB Atlas account](https://www.mongodb.com/cloud/atlas/register)
 - [Neurelo account](https://dashboard.neurelo.com/register)
 - [AWS account](https://aws.amazon.com/account/); Lambda access is necessary 

## Setting up our MongoDB cluster 

Our first step is to spin up a free MongoDB cluster and download the sample dataset. For help on how to do this, please refer to our [tutorial](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). 

For this tutorial, we will be using the `sample_restaurants` collection that is located inside the sample dataset. Please ensure you have included the correct IP address access for this tutorial, along with a secure username and password as you will need these throughout. 

Once your cluster is up and running, we can start setting up our Neurelo project.

## Setting up our Neurelo project

Once we have our MongoDB cluster created, we need to create a project in Neurelo. For help on this step, please refer to our first tutorial in this series, [Neurelo and MongoDB: Getting Started and Fun Extras](https://www.mongodb.com/developer/products/mongodb/neurelo-getting-started/). 

Save your API key someplace safe. Otherwise, you will need to create a new key if it gets lost. Additionally, please ensure your Neurelo project is connected to your MongoDB cluster. For help on grabbing a MongoDB connection string, [we have directions](https://www.mongodb.com/basics/mongodb-connection-string#:~:text=How%20to%20get%20your%20MongoDB,connection%20string%20for%20your%20cluster) to guide you through it. Now, we can move on to setting up our AWS Lambda function. 

##  Creating our AWS Lambda function

Log into your AWS account and access Lambda either through the search bar or in the “Services” section. Click on the orange “Create function” button and make sure to press the “Author from scratch” option on the screen that pops up. Select a name for your function — we are using “ConnectTest” to keep things simple — and then, choose “Python 3.12” for your runtime, since this is a Python tutorial! Your Lambda function should look like this prior to hitting “Create function.”

![[Fig 1: Create Lambda function screen]](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0fa5893d1c742669/65eb230e2d59d4c792828d80/Screenshot_2024-03-08_at_9.38.41_AM.png)

Once you’re taken to the “Function overview” page, we can start writing our code to perfectly integrate MongoDB Atlas, Neurelo, and AWS Lambda. Let’s dive into it.

## Part 1: The integration

Luckily, we don’t need to import any requirements for this Lambda function tutorial and we can write our code directly into the function we just created. 

The first step is to import the packages `urllib3` and `json` with the line:

```
import urllib3, json
```
These two packages hold everything we need to deal with our connection strings and make it so we don’t need to write our code in a separate IDE. 

Once we have our imports in, we can configure our API key to our Neurelo environment. We are using a placeholder `API_KEY`, and for ease in this tutorial, you can put your key directly in. But it’s not good practice to ever hardcode your keys in code, and in a production environment, it should never be done. 

```
# Put in your API Key to connect to your Neurelo environment
NEURELO_API_KEY = ‘API_KEY’
```
Once you’ve set up your API key connection, we can set up our headers for the REST API call. For this, we can take the auto-generated `lambda_function` function and edit it to better suit our needs:

```
def lambda_handler(event, context):
   
    # Setup the headers
    headers = {
        'X-API-KEY': NEURELO_API_KEY
    }
    
    # Creating a PoolManager instance for sending HTTP requests
    http = urllib3.PoolManager()
```
Here, we are creating a dictionary named `headers` to set the value of our API key. This step is necessary so Neurelo can authenticate our API request and we can return our necessary documents. We are then utilizing the `PoolManager` class to manage our server connections. This is an efficient way to ensure we are reusing connections with Lambda instead of creating a new connection with each individual call. For this tutorial, we are only using one connection, but if you have a more complex Lambda or a project with the need for multiple connections, you will be able to see the magic of the `PoolManager` class a bit more.  

Now, we are ready to set up our first API call! Please recall that in this first step, we are connecting to our “restaurants” collection within our `sample_restaurants` database and we are returning our necessary documents. 

We have decided that we want to retrieve a list of restaurants from this collection that fit specific criteria: These restaurants are located in the borough of Brooklyn, New York, and serve American cuisine. Prior to writing the code below, we suggest you take a second to look through the sample database to view the fields inside our documents. 

So now that we’ve defined the query parameters we are interested in, let’s translate it into a query request. We are going to be using three parameters for our query: “filter,” “take,” and “select.” These are the same parameter keys from our [first article in this series](https://www.mongodb.com/developer/products/mongodb/neurelo-getting-started/), so please refer back to it if you need help. We are using the “filter” parameter to ensure we are receiving restaurants that fit our criteria of being in Brooklyn and that are American, the “take” parameter is so we only return five documents instead of thousands (our collection has over 25,000 documents!), and the “select” parameter is so that only our specific fields are being returned in our output. 

Our query request will look like this:
```
# Define the query parameters
    params1 = {
        'filter': '{"AND": {"borough": {"equals": "Brooklyn"}, "cuisine": {"equals": "American"}}}',
        'take': '5',
        'select': '{"id": false, "name": true, "borough": true, "cuisine": true}',
    }
```
Don’t forget to send a GET request with our necessary parameters, and set up some print statements so we can see if our request was successful. Once completed, the whole code block for our Part 1 should look something like this: 
```
import urllib3, json

# Configure the API Key for our Neurelo environment
NEURELO_API_KEY = 'API_KEY'

def lambda_handler(event, context):
   
    # Setup the headers
    headers = {
        'X-API-KEY': NEURELO_API_KEY
    }
    
    # Creating a PoolManager instance for sending HTTP requests
    http = urllib3.PoolManager()

    # Choose the "restaurants" collection from our Neurelo environment connected to 'sample_restaurants'
    api1 = 'https://us-east-2.aws.neurelo.com/rest/restaurants'
  
    # Define the query parameters
    params1 = {
        'filter': '{"AND": {"borough": {"equals": "Brooklyn"}, "cuisine": {"equals": "American"}}}',
        'take': '5',
        'select': '{"id": false, "name": true, "borough": true, "cuisine": true}',
    }
   
    # Send a GET request with URL parameters
    response = http.request("GET", api1, headers=headers, fields=params1)
  
    # Print results if the request was successful
    if response.status == 200:
        # Print the JSON content of the response
        print ('Restaurants Endpoint: ' + json.dumps(json.loads(response.data), indent=4))
```
And our output will look like this:
![[Fig 2: Results after calling our first API call]](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt2258218193b8e11a/65eb239907cf271f044d1157/Screenshot_2024-03-08_at_9.41.16_AM.png)

Congratulations! As you can see, we have successfully returned five American cuisine restaurants located in Brooklyn, and we have successfully integrated our MongoDB cluster with our Neurelo project and have used AWS Lambda to access our data. 

Now that we’ve set everything up, let’s move on to the second part of our tutorial, where we will filter our results with a custom API endpoint for the best restaurants possible. 

## Part 2: Filtering our results further with a custom API endpoint

Before we can call our custom endpoint to filter for our desired results, we need to create one. While Neurelo has a large list of auto-generated endpoints available for your project, sometimes we need an endpoint that we can customize with a complex query to return information that is nuanced. From the sample database in our cluster, we can see that there is a `grades` field where the grade and score received by each restaurant exist. 

![[Fig 3: view of the grades and scores in our documents]](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltbe8595b3c208a1d9/65eb23cdfd462342c967dc47/Screenshot_2024-03-08_at_9.42.10_AM.png)

So, what if we want to return documents based on their scores? Let’s say we want to expand our search and find restaurants that are really good restaurants. 

Head over to Neurelo and access the “Definitions” tab on the left-hand side of the screen. Go to the “Custom Queries” tab and create a complex query named “getGoodRestaurants.” For more help on this section, please refer to the [first article](https://www.mongodb.com/developer/products/mongodb/neurelo-getting-started/) in this series for a more detailed explanation. 

We want to filter restaurants where the most recent grades are either “A” or “B,” and the latest grade score is greater than 10. Then, we want to aggregate the restaurants by cuisine and borough and list the restaurant name, so we can know where to go!

Our custom query will look like this:

```
{
 "aggregate": "restaurants",
 "pipeline": [
   {
     "$match": {
       "borough": "Brooklyn",
       "cuisine": "American",
       "grades.0.grade": {
         "$in": [
           "A",
           "B"
         ]
       },
       "grades.1.grade": {
         "$in": [
           "A",
           "B"
         ]
       },
       "grades.0.score": {
         "$gt": 10
       }
     }
   },
   {
     "$limit": 5
   },
   {
     "$group": {
       "_id": {
         "cuisine": "$cuisine",
         "borough": "$borough"
       },
       "restaurants_info": {
         "$push": {
           "name": "$name"         
}
       }
     }
   }
 ],
 "cursor": {}
}

```
Great! Now that we have our custom query in place, hit the “Commit” button at the top of the screen, add a commit message, and make sure that the “Deploy to environment” option is selected. This is a crucial step that will ensure that we are committing our custom query into the definitions repo for the project and deploying the changes to our environment. 

Now, we can head back to Lambda and incorporate our second endpoint to return restaurants that have high scores serving our desired food in our desired location. 

Add this code to the bottom of the previous code we had written. 

```
# Choose the custom-query endpoint from our Neurelo environment connected to 'sample_restaurants'
    api2 = 'https://us-east-2.aws.neurelo.com/custom/getGoodRestaurants'

    # Send a GET request with URL parameters
    response = http.request("GET", api2, headers=headers)
    
    if response.status == 200:
        # Print the JSON content of the response
        print ('Custom Query Endpoint: ' + json.dumps(json.loads(response.data), indent=4))
```
Here, we are choosing our custom endpoint, `getGoodRestaurants`, and then sending a GET request to acquire the necessary information. 

Please deploy the changes in Lambda and hit the “Test” button. 

Your output will look like this:
![[Fig 4: custom complex query endpoint output in Lambda]](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc0d9be16d3358fff/65eb241d0194ca245927a6f2/Screenshot_2024-03-08_at_9.43.30_AM.png)

As you can see from the results above, we have received a sample size of five American cuisine, Brooklyn borough restaurants that meet our criteria and are considered good restaurants! 

## Conclusion

In this tutorial, we have covered how to properly integrate a MongoDB Atlas cluster with our Neurelo project and return our desired results by using AWS Lambda. We have shown the full process of utilizing our Neurelo project automated API endpoints and even how to use unique and fully customizable endpoints as well! 

For more help with using [MongoDB Atlas](https://www.mongodb.com/docs/atlas/), [Neurelo](https://docs.neurelo.com/), and [AWS Lambda](https://docs.aws.amazon.com/lambda/), please visit the hyperlinked documentation. 

> This tutorial is the second in our series. Please check out the first tutorial: [Neurelo and MongoDB: Getting Started and Fun Extras](https://www.mongodb.com/developer/products/mongodb/neurelo-getting-started/).

Follow along with this in-depth tutorial covering the integration of MongoDB Atlas, Neurelo, and AWS Lambda to build a restaurant locator.

Guru Kamat

Content by Guru Kamat

How to Get Started With Neurelo and MongoDB

Building a Restaurant Locator Using Atlas, Neurelo, and AWS Lambda