> This is the first of a series of posts that will present our publicly developed [Project Handbook](https://www.notion.so/meilisearch/Project-Handbook-e818a836dd3f4df1bde7c3989c9a0ae4).

Any open source project with the intention to commercialize its value creation should be able to answer this question: **How will you make money?**

Seth Godin's "[The Modern Business Plan](https://seths./blog/2010/05/the-modern-business-plan/)" provides a very useful, prose-focused template that lends itself well to consumption by the general public. This is the v0.1 release of our _Open Business Plan_.

> It’s not clear to me why business plans are the way they are, but  they’re often misused to obfuscate, bore and show an ability to comply with expectations. If I want the real truth about a business and where  it’s going, I’d rather see something else. I’d divide the modern  business plan into five sections:  
>   
> **1\. Truth**  
> **2\. Assertions**  
> **3\. Alternatives**  
> **4\. People**  
> **5\. Money**

Truth
-----

> The truth section describes the world as it is.  Footnote if you want to, but tell me about the market you are entering, the needs that already exist, the competitors in your space, technology standards, the way others have succeeded and failed in the past. The more specific the better. The more ground knowledge the better. The more visceral the stories, the better. The point of this section is to be sure that you’re clear about the way you see the world, and that you and I agree on your assumptions. This section isn’t partisan, it takes no positions, it just states how things are. Truth can take as long as you need to tell it. It can include spreadsheets, market share analysis and anything I need to know about how the world works.

If you want to set up an advanced content search for your website or app _today_, the leading options are [Algolia](https://docs.meilisearch.com/learn/what_is_meilisearch/comparison_to_alternatives.html#meilisearch-vs-algolia) and [Elastic](/blog/why-should-you-use-meilisearch-over-elasticsearch/) both great products, but neither can service a large segment of small to medium-sized businesses that are operating on a tight budget and/or need an easily maintainable setup for on-premises management.

We are not setting out to _kill_, _crush_ or _destroy_ our competitors. We are here to _question_, _challenge_, and _elevate_ the status quo.

Meili SAS is in large part modeling itself after Algolia and Elastic. We also take loads of inspiration from the business strategies of WordPress, Discourse, Sentry, CockroachDB and TimescaleDB. Like them, we are building a [Commercial Open Source Company](https://coss.media/coss-company-value-creation-capture-fundamentals/).

One of our most important competitive advantages is [Rust](https://www.rust-lang.org/). It enables us to confidently engineer the highly complex machinery of a search engine without crippling risk of technical debt or dead-ends. With Rust we can fearlessly explore the next frontier of search, safe in the knowledge that our code can always be refactored without bringing the whole foundation down.

Assertion
---------

> The assertions section is your chance to describe how you’re going to change things. We will do X, and then Y will happen. We will build Z with this much money in this much time. We will present Q to the market and the market will respond by taking this action. This is the heart of the modern business plan. The only reason to launch a project is to change something, and I want to know what you’re going to do and what impact it’s going to have.

We are going to spend the next year building _trust_, starting with an extensive **developer community**. We intend to rally this community around our out-in-the-open construction of Meilisearch as the easiest search engine of its kind to set up and modify to your application's needs.

Eventually, customers will get to choose between the instant value of SaaS, or the full control of self-hosted.

SaaS will be our initial focus as a company. It's the more proven model available to us. But we won't build any exclusives into our offering; any search feature we build for our SaaS offering will either be open source or source-available (i.e. freely available for non-commercial use; purchasable license for commercial use).

### Incentives for self-hosting

We intend to structure our business in a way that incentivizes a continued investment in the self-hosting capabilities of Meilisearch. Many open source companies with a SaaS offering end up with inverse incentives to continue improving their user-facing installation story because it competes with their SaaS business. By exploring fair ways to monetize our on-premises offering in commercial contexts we will ensure an ongoing equilibrium in our incentives.

### Self-hosting as a self-negotiator on pricing

A SaaS product that can be alternatively self-hosted with ease is inherently pricing-transparent. When discerning customers can effortlessly compare the experience of our managed SaaS versus our on-premises package, it keeps our pricing honest.

Alternatives
------------

> Of course, this \[assertion\] section will be incorrect. You will make  assertions that won’t pan out. You’ll miss budgets and deadlines and  sales. So the alternatives section tells me what you’ll do if that happens. How much flexibility does your product or team have? If your assertions don’t pan out, is it over?

The likes of Elastic, CockroachDB and GitLab have proven that there is not a singular best option for product delivery. Many customers just want the simplicity of SaaS, but many others **must** have on-premise services. We do not yet know which there will be more appetite for when it comes to Meilisearch, but we are prepared to follow the path of least resistance.

People
------

> The people section rightly highlights the key element… who is on your team, who is going to join your team. ‘Who’ doesn’t mean their resume, who means their attitudes and abilities and track record in shipping.

[Meet the team](https://meilisearch.notion.site/MeiliSearch-Team-b7f24733f4944fa9b09fd518d6fc3eff) (WIP)

Money
-----

> And the last section is all about money. How much do you need, how will you spend it, what does cash flow look like, P&Ls, balance sheets, margins and exit strategies.

We raised a pre-seed round in may, and are backed by LocalGlobe, Seedcamp and Kima. We have already partnered with industry heavyweights like Louis Vuitton and [Platform.sh](http://platform.sh/).

Next step is to create pages similar to these:

*   [https://docs.opencollective.com/help/about/investors](https://docs.opencollective.com/help/about/investors)
*   [https://docs.opencollective.com/help/about/the-open-collective-way/core-contributors-compensation](https://docs.opencollective.com/help/about/the-open-collective-way/core-contributors-compensation)

* * *

We hope you enjoyed this _[very early](https://en.wikipedia.org/wiki/Release_early,_release_often)_ v0.1.0 release of our Open Business Plan. You'll notice that Seth's article asks for several items of information that we have not yet addressed here. We hope to share more over time, but this requires more dialogue with our investors and other stakeholders.

Please let us know what information you'd most like us to share, and we will prioritize it. Come talk to us in the comments on [/r/opensource](https://www.reddit.com/r/opensource/comments/gv7kht/meilisearch_open_business_plan_v01/), [/r/rust](https://www.reddit.com/r/rust/comments/gv7ugp/meilisearch_open_business_plan_v01/), or find us on our [default community channels](https://docs.meilisearch.com/learn/what_is_meilisearch/contact.html).

> Interested in what Meilisearch could do for your business? If you [answer this survey](https://meilisearch.typeform.com/to/tsTOTw) you will be the first to know when our initial service offering is operational.

Meilisearch - Open business plan v0.1

Integrate a relevant search bar to your documentation
=====================================================

You might have noticed the search bar in [our documentation](https://docs.meilisearch.com/).

![](https://unable-actionable-car.media.strapiapp.com/vuepress_searchbar_demo_b1b886ebc2.gif)

MeiliSearch docs search bar demo

And you are probably wanting the same for your own documentation!

This tutorial will guide you through the steps of building a relevant and powerful search bar for your documentation 🚀

1.  Run a MeiliSearch Instance
2.  Scrape your content
3.  Integrate the Search Bar

Run a MeiliSearch Instance
--------------------------

First of all, you need your documentation content to be scraped and pushed into a MeiliSearch instance.

You can install and run MeiliSearch on your machine using `curl`.

```bash
$ curl -L https://install.meilisearch.com | sh
$ ./meilisearch --master-key=myMasterKey

```

There are [other ways to install MeiliSearch](https://docs.meilisearch.com/reference/features/installation.html#download-and-launch).

MeiliSearch is open-source and can run either on your server or on any cloud provider.

> **Note:** The host URL and the API key you will provide in the next steps correspond to the credentials of this MeiliSearch instance.  
> In the example above, the host URL is `http://localhost:7700` and the API key is `myMasterKey`.

Scrape your Content
-------------------

The Meili team provides and maintains a [scraper tool](https://github.com/meilisearch/docs-scraper) to automatically read the content of your website and store it into an index in MeiliSearch.

### Configuration File

The scraper tool needs a configuration file to know what content you want to scrape, this is done by providing selectors (e.g. the HTML tag).

Here is an example of a basic configuration file:

```json
{
  "index_uid": "docs",
  "start_urls": ["https://www.example.com/doc/"],
  "sitemap_urls": ["https://www.example.com/sitemap.xml"],
  "stop_urls": [],
  "selectors": {
    "lvl0": {
      "selector": ".docs-lvl0",
      "global": true,
      "default_value": "Documentation"
    },
    "lvl1": {
      "selector": ".docs-lvl1",
      "global": true,
      "default_value": "Chapter"
    },
    "lvl2": ".docs-content .docs-lvl2",
    "lvl3": ".docs-content .docs-lvl3",
    "lvl4": ".docs-content .docs-lvl4",
    "lvl5": ".docs-content .docs-lvl5",
    "lvl6": ".docs-content .docs-lvl6",
    "text": ".docs-content p, .docs-content li"
  }
}

```

The `index_uid` field is the index identifier in your MeiliSearch instance in which your website content is stored. The scraping tool will create a new index if it does not exist.

The `docs-content` class is the main container of the textual content in this example. Most of the time, this tag is a `<main>` or an `<article>` HTML element.

`lvlX` selectors should use the standard title tags like `h1`, `h2`, `h3`, etc. You can also use static classes. Set a unique `id` or `name` attribute to these elements.

Every searchable `lvl` elements outside this main documentation container (for instance, in a sidebar) must be `global` selectors. They will be globally picked up and injected to every document built from your page.

If you use VuePress for your documentation, you can check out the [configuration file](https://github.com/meilisearch/documentation/blob/master/.vuepress/docs-scraper/docs-scraper.config.json) we use in production. In our case, the main container is `theme-default-content` and the selector the titles and sub-titles are `h1`, `h2`...

### Run the Scraper

You can run the scraper with Docker. With our local MeiliSearch instance set up at the first step, we run:

```bash
$ docker run -t --rm \
    --network=host \
    -e MEILISEARCH_HOST_URL='http://localhost:7700' \
    -e MEILISEARCH_API_KEY='myMasterKey' \
    -v <absolute-path-to-your-config-file>:/docs-scraper/config.json \
    getmeili/docs-scraper:latest pipenv run ./docs_scraper config.json

```

> **Note:** If you don't want to use Docker, here are [other ways to run the scraper](https://github.com/meilisearch/docs-scraper#installation-and-usage).

`<absolute-path-to-your-config-file>` should be the **absolute** path of your configuration file defined at the previous step.

The API key you must provide should have the permissions to add documents into your MeiliSearch instance. In a production environment, we recommend providing the private key instead of the master key, as it is safer and it has enough permissions to perform such requests.

_More about [MeiliSearch authentication](https://docs.meilisearch.com/reference/features/authentication.html)._

> **Tip:** We recommend running the scraper at each new deployment of your documentation, [as we do for the MeiliSearch's one](https://github.com/meilisearch/documentation/blob/master/.github/workflows/gh-pages-scraping.yml).

Integrate the Search Bar
------------------------

If your documentation is not a VuePress application, you can skip the "For a VuePress Documentation" section and go directly to "For All Kinds of Documentation".

### For a VuePress Documentation

If you use VuePress for your documentation, we provide a [VuePress plugin](https://github.com/meilisearch/vuepress-plugin-meilisearch). This plugin is used in production in the MeiliSearch documentation.

![VuePress plugin example](https://unable-actionable-car.media.strapiapp.com/vuepress_plugin_example_ba1e4b4668.png)

VuePress plugin example

In your VuePress project:

```bash
$ yarn add vuepress-plugin-meilisearch
# or
$ npm install vuepress-plugin-meilisearch

```

In your `config.js` file:

```js
module.exports = {
  plugins: [
    [
      "vuepress-plugin-meilisearch",
      {
        "hostUrl": "<your-meilisearch-host-url>",
        "apiKey": "<your-meilisearch-api-key>",
        "indexUid": "docs"
      }
    ],
  ],
}

```

The `hostUrl` and the `apiKey` fields are the credentials of the MeiliSearch instance. Following on from this tutorial, they are respectively `http://localhost:7700` and `myMasterKey`.

`indexUid` is the index identifier in your MeiliSearch instance in which your website content is stored. It has been defined in the config file.

These three fields are mandatory, but more [optional fields are available](https://github.com/meilisearch/vuepress-plugin-meilisearch#customization) to customize your search bar.

> **Warning:** Since the configuration file is public, we strongly recommend providing the MeiliSearch public key in a production environment, which is enough to perform search requests.  
>   
> Read more about [MeiliSearch authentication](https://docs.meilisearch.com/reference/features/authentication.html#authentication).

### For All Kinds of Documentation

If you don't use VuePress for your documentation, we provide a [front-end SDK](https://github.com/meilisearch/docs-searchbar.js) to integrate a powerful and relevant search bar to any documentation website.

![docs-searchbar.js example](https://unable-actionable-car.media.strapiapp.com/docs_searchbar_example_83b1557e12.png)

docs-searchbar.js example

```html
<!DOCTYPE html>
<html>
  <head>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docs-searchbar.js@{version}/dist/cdn/docs-searchbar.min.css" />
  </head>

  <body>
    <input type="search" id="search-bar-input">
    <script src="https://cdn.jsdelivr.net/npm/docs-searchbar.js@{version}/dist/cdn/docs-searchbar.min.js"></script>
    <script>
      docsSearchBar({
        hostUrl: '<your-meilisearch-host-url>',
        apiKey: '<your-meilisearch-api-key>',
        indexUid: 'docs',
        inputSelector: '#search-bar-input',
        debug: true // Set debug to true if you want to inspect the dropdown
      });
    </script>
  </body>
</html>

```

The `hostUrl` and the `apiKey` fields are the credentials of the MeiliSearch instance. Following on from this tutorial, they are respectively `http://localhost:7700` and `myMasterKey`.

`indexUid` is the index identifier in your MeiliSearch instance in which your website content is stored. It has been defined in the config file.  
`inputSelector` is the `id` attribute of the HTML search input tag.

> **Warning:** We strongly recommend providing the MeiliSearch public key in a production environment, which is enough to perform search requests.  
> Read more about [MeiliSearch authentication](https://docs.meilisearch.com/reference/features/authentication.html).

The default behavior of this library fits perfectly for a documentation search bar, but you might need [some customizations](https://github.com/meilisearch/docs-searchbar.js#customization).

> **Note:** For more concrete examples, you can check out this [basic HTML file](https://github.com/meilisearch/docs-searchbar.js/blob/master/scripts/playground.html) or [this more advanced Vue file](https://github.com/meilisearch/vuepress-plugin-meilisearch/blob/master/MeiliSearchBox.vue).

What's next?
------------

At this point you should have a working search engine on your website, congrats! 🎉

You can check [this tutorial](https://docs.meilisearch.com/running-production/) if you now want to run MeiliSearch in production!

How to integrate a relevant search bar to your documentation

A quick introduction
--------------------

Hopefully, you already know that [MeiliSearch](https://github.com/meilisearch/MeiliSearch) is a powerful and fast open-source search engine built in [Rust](https://www.rust-lang.org). It was designed to provide users with a very useful and customizable search experience including out-of-the-box features such as typo-tolerance, filtering, and synonyms for any kind of project.

Running a Meilisearch instance for testing purposes is incredibly easy and can be done in [many ways](https://docs.meilisearch.com/learn/tutorials/getting_started.html): using Docker, brew, aptitude, binaries, a simple curl, or even the source code. If you are new to MeiliSearch, we suggest that you take a tour around the documentation.

Using MeiliSearch on your own machine for your weekend project is fun, let's agree on that. However, you may want to go live and deploy a project in production, to take it to the next level. What steps and details would you need to **deploy MeiliSearch in production** and ensure it is **safe and ready to use**?

Get your MeiliSearch ready for production
-----------------------------------------

For this tutorial, we will be using a Debian 10 server, running on DigitalOcean. You can easily try it on your own, with plans starting at $5/month. And if you want some credits to start running your MeiliSearch and are not already registered on DigitalOcean, you can get $100 for free using [this referral link](https://m.do.co/c/7c67bd97e101).

Prerequisites
-------------

*   An up-to-date server that runs Debian 10
*   An ssh keypair to connect to that machine
*   MeiliSearch is a database which means that it needs a file system it can write to, and which must be persistent.

> _TIPS:_ learn how to connect via SSH to your [DigitalOcean droplet](https://www.digitalocean.com/docs/droplets/how-to/connect-with-ssh/) or any [Linux or windows server](https://phoenixnap.com/kb/ssh-to-connect-to-remote-server-linux-or-windows)

Step 1: Install MeiliSearch
---------------------------

Installing and running MeiliSearch is easy and straightforward. In order to keep this tutorial as simple as possible, let's use a script that will carry out the installation process. It will copy a binary of MeiliSearch to your machine and enable you to use it immediately.

Once you are logged in into your machine via SSH, ensure your system and its dependencies are up-to-date before proceeding with the installation.

```bash
# Update the list of available packages and their versions
$ apt update
# Install curl which is required to install MeiliSearch in the next step
$ apt install curl -y
# Install MeiliSearch latest version from the script
$ curl -L https://install.meilisearch.com | sh

```

> The different options to achieve a MeiliSearch installation are detailed in **[this guide](https://docs.meilisearch.com/reference/features/installation.html#download-and-launch)**.  
> It is important to know that there are different ways to get MeiliSearch running on your machine. As an open source project, you can always compile the latest stable release of MeiliSearch from the source code to ensure the binary uses your achitecture in the best possible way.

You can always check the latest MeiliSearch stable version, and get MeiliSearch for the Operating System of your choice, by visiting the following link:

**[Latest MeiliSearch Stable Version](https://github.com/meilisearch/MeiliSearch/releases/latest)**

MeiliSearch is finally installed and ready to use. To make it accessible from everywhere in your system, move the binary file into your system binaries folder:

```bash
# Move the MeiliSearch binary to your system binaries
$ mv ./meilisearch /usr/bin/

```

You can now start using MeiliSearch! In your terminal, run:

```bash
$ meilisearch

# --- Expected output for v0.10.1 ---
888b     d888          d8b 888 d8b  .d8888b.                                    888
8888b   d8888          Y8P 888 Y8P d88P  Y88b                                   888
88888b.d88888              888     Y88b.                                        888
888Y88888P888  .d88b.  888 888 888  "Y888b.    .d88b.   8888b.  888d888 .d8888b 88888b.
888 Y888P 888 d8P  Y8b 888 888 888     "Y88b. d8P  Y8b     "88b 888P"  d88P"    888 "88b
888  Y8P  888 88888888 888 888 888       "888 88888888 .d888888 888    888      888  888
888   "   888 Y8b.     888 888 888 Y88b  d88P Y8b.     888  888 888    Y88b.    888  888
888       888  "Y8888  888 888 888  "Y8888P"   "Y8888  "Y888888 888     "Y8888P 888  888

[2020-05-04T11:47:13Z INFO  meilisearch] Database path: "./data.ms"
[2020-05-04T11:47:13Z INFO  meilisearch] Start server on: "127.0.0.1:7700"

```

Step 2: Run MeiliSearch as a service
------------------------------------

In Linux environments, a `service` is a process that can be launched when the operating system is booting and which will keep running in the background. One of its biggest advantages is making your program available at any moment. Even if some execution problems or crashes occur, the service will be restarted and your program will be run again.

> If you are new to services and `systemd`, you can learn more about the basics of Linux services [here](https://www.hostinger.com/tutorials/manage-and-list-services-in-linux/).

In Debian and other Linux distributions, `systemd` allows you to create and manage your own custom services. In order to make sure that MeiliSearch will always respond to your requests, you can build your own service. This way, you will ensure its availability in case of a crash or in case of system reboot. If any of these occur, `systemd` will automatically restart MeiliSearch.

### 2.1 Create a service file

Service files are text files that tell your operating system how to run your program, and when. They live in the `/etc/systemd/system` directory, and your system will load them at boot time. In this case, let's use a very simple service file that will run MeiliSearch on port `7700`.

To run MeiliSearch in a production environment, use the `--env` flag. To generate a master key that will let MeiliSearch create reading and writing keys, use the `--master-key` flag. With those keys, you can easily control who can access or create new documents, indexes, or change the configuration. You can change the `Master Key` to any value in the following command. However, for security concerns, it's better to choose a safe and random key, never share it and, just, **keep it safe**.

```bash
$ cat << EOF >/etc/systemd/system/meilisearch.service
[Unit]
Description=MeiliSearch
After=systemd-user-sessions.service

[Service]
Type=simple
ExecStart=/usr/bin/meilisearch --http-addr 127.0.0.1:7700 --env production --master-key Y0urVery-S3cureAp1K3y

[Install]
WantedBy=default.target
EOF


```

> For more information on MeiliSearch authentication and API keys see the **[Authentication Docs](https://docs.meilisearch.com/reference/features/authentication.html)**. For more information on MeiliSearch options and flags see the **[MeiliSearch configuration options](https://docs.meilisearch.com/reference/features/configuration.html)**

As for now, it is not time yet to expose your MeiliSearch instance to the external world. To keep running it safely inside your own environment, make it available locally at `127.0.0.1`. This means that only programs running on your machine are allowed to make requests to your MeiliSearch instance.

### 2.2. Enable and start service

The service file you just built is all you need for creating your service. Now you must `enable` it to tell the operating system that we want it to run MeiliSearch at every boot. You can then `start` the service to make it run immediately. Ensure everything is working smoothly by checking the service `status`.

```bash
# Set the service meilisearch
$ systemctl enable meilisearch

# Start the meilisearch service
$ systemctl start meilisearch

# Verify that the service is actually running
$ systemctl status meilisearch

-# --- Expected output ---
● meilisearch.service - MeiliSearch
   Loaded: loaded (/etc/systemd/system/meilisearch.service; enabled; vendor preset: enabled)
   Active: active (running) since Fri 2020-04-10 14:27:49 UTC; 1min 8s ago
 Main PID: 14960 (meilisearch)

```

At this point, MeiliSearch is installed and running. It is protected from eventual crashes, system restarts, and most of the problems it could find while running. But it is still hidden and protected inside the walls (or firewalls) of your machine, and unreachable from the outside world. You can stop here if all the requests you do to MeiliSearch are done by another application living in the same machine.

But you probably want to open your MeiliSearch to the outside world, and for now, it is isolated. Let's fix that in a safe way.

Step 3: Secure and finish your setup. Using a Reverse Proxy, domain name and HTTPS
----------------------------------------------------------------------------------

It's time to safely make your brand new MeiliSearch available to be requested from the outside world. For this purpose, you will use two of the main technologies available on the web: a Reverse Proxy and SSL/TLS.

### 3.1. Creating a Reverse Proxy with [Nginx](https://www.nginx.com/)

A reverse proxy is basically an application that will handle every communication between the outside world and your internal applications. Nginx will receive external HTTP requests and redirect them to MeiliSearch. When MeiliSearch has done its amazing job, it will communicate its response to Nginx, which will then transfer the latter to the user who originally sent the request. This is a common way to isolate and protect any application by adding a robust, secure, and fast gate-keeper such as Nginx, one of the safest and most efficient tools available online, and of course, open-source!

> Reverse proxies are very useful regarding security, performance, scalability, and logging concerns. If you are new to Reverse proxies, you may enjoy this article explaining the why and the how of [reverse proxies](https://www.keycdn.com/support/nginx-reverse-proxy).

Configuring Nginx as a proxy server is really simple. First of all, install it on your machine.

```bash
# Install Nginx on Debian
$ apt-get install nginx -y

```

First, deleting the default configuration file is important as the default port for HTTP, the `port 80`, is used by Nginx by default. Thus, trying to use it for MeiliSearch will create a conflict. Replace the default file by your own configuration file. You can also make MeiliSearch listen to another port by specifying it in the Nginx configuration file, but we will not cover this option in this tutorial.

```bash
# Delete the default configuration file for Nginx
$ rm -f /etc/nginx/sites-enabled/default

# Add your configuration file specifying the Reverse Proxy settings
$ cat << EOF > /etc/nginx/sites-enabled/meilisearch
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    location / {
        proxy_pass  http://127.0.0.1:7700;
    }
}
EOF

```

Finally, enable and start the Nginx service again to make sure it is still available.

```bash
# Reload the operating system daemons / services
$ systemctl daemon-reload

# Enable and start Nginx service
$ systemctl enable nginx
$ systemctl restart nginx

```

MeiliSearch is now up, deployed in a production environment, using a safe API key, and being served by a Reverse Proxy Nginx. You should now be able to send requests to your server from the outside world. Open your web browser and visit: ([http://your-ip-address](http://your-ip-address)). The IP address is the same you used to connect to your machine via SSH in Step 1.

> If you want to learn more about using Nginx as a Reverse Proxy, see [this dedicated documentation](https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/).

The only remaining problem is that MeiliSearch processes requests via HTTP without any additional security. The content that is being transmitted over HTTP could easily be read or modified by attackers, and someone could get full or partial access to your data. In order to prevent this to happen, it's important to use the HTTPS, which will enable you to use a SSL/TLS certificate, and securely transmit data.

### 3.2. Set up SSL/TLS for your MeiliSearch

SSL will let the user or client establish an authenticated connection to MeiliSearch. In this way, a user can verify server's identity before sending sensitive data or making any request to it. Then, data is sent in an encrypted way that only MeiliSearch server will be able to decrypt, providing you a fast, reliable, and automatic layer of security.

In most cases, when enabling SSL, you may want to use your own domain name (or a sub-domain). The first step you need to follow is to register your own domain name and change the DNS records. To make your domain name point to your newly installed MeiliSearch server, you just need to add an `A record` pointing to the IP address used to connect to your own server. This process is simple and fast but can vary for every domain name provider. Thus, we will not cover that process in this article.

> When you register a domain name and add an `A record`, you should be automatically able to request MeiliSearch directly by using that domain name.  
> To illustrate this, if you had registered your domain name `example.com`, requesting indexes would be done at [http://example.com/indexes](http://example.com/indexes)

Once your domain name has been set up, you are ready to configure SSL/TLS and use HTTPS. You have two different options to achieve this goal. The first one is using [Certbot](https://certbot.eff.org/), an amazing, free, and very easy to use tool. If you already have SSL certificates issued from a `Certificate Authority or CA` for your domain name, the second option covers the steps you need to follow. Then, you will be ready to use MeiliSearch safely in production!

#### 3.2. Option A: Certbot

Using certbot in your Linux server is very easy and straightforward. This tool will generate a free SSL/TLS certificate for your domain name, and automatically handle its installation on your server. The certbot documentation contains detailed instructions for many operating systems and servers, but we will follow the instructions for [Certbot on Debian with Nginx](https://certbot.eff.org/lets-encrypt/debianbuster-nginx).

First of all, install the packages on your system:

```bash
$ sudo apt-get install certbot python-certbot-nginx -y

```

Let's run the Certbot script to be guided through the installation process:

```bash
certbot --nginx

```

Enter your email address, agree to the Terms and Conditions, and input your domain name. You will then be prompted with these options:

```bash
Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.

```

We recommend that you choose option 2, to redirect HTTP to HTTPS and always use a secure connection. You should be able to request your domain name with SSL as in `https://example.com` or `https://example.com/indexes`.

#### 3.2. Option B: Custom SSL/TLS Certificates

When a `Certificate Authority` issues a SSL certificate for you, you receive at least two files with encrypted keys:

*   Your **certificate** (commonly named `your_domain_name.pem` or `example.pem`)
*   Your **key** (commonly named `your_domain_name.key` or `example.key`)

> `example.pem` and `example.key` will be used in the following examples. Make sure to replace `example` by the names of your own certificate files.

All you need to do is store the certificate files in a secure location and use appropriate file system security permissions. Then, set the location of the certificates in Nginx configuration. It is also strongly recommended to redirect all HTTP requests to HTTPS (port 80 to 443).

First, let's copy your certificate files in their conventional directory so the server can find them:

```bash
# Create a directory /etc/ssl/example to store the certificate files
$ mkdir -p /etc/ssl/example

# Move your files to /etc/ssl/example. We will suppose that your
# files are called example.pem and example.key

$ mv path-to-your-files/example.pem /etc/ssl/example/
$ mv path-to-your-files/example.key /etc/ssl/example/

```

Finally, we create a new Nginx configuration file, and restart the daemons and Nginx service

> Remember to replace `example.com` in both `server_name` fields with your **own domain name**

```bash

# Replace example.com in both `server_name` fields with your own domain name

$ cat << EOF > /etc/nginx/sites-enabled/meilisearch
server {
      listen 80 default_server;
      listen [::]:80 default_server;

      server_name example.com;

      return 301 https://\$server_name\$request_uri;
}
server {
    server_name example.com;

    location / {
        proxy_pass  http://127.0.0.1:7700;
    }

    listen [::]:443 ssl ipv6only=on;
    listen 443 ssl;

    access_log /var/log/nginx/nginx.vhost.access.log;
    error_log /var/log/nginx/nginx.vhost.error.log;
    ssl_certificate /etc/ssl/example/example.pem;
    ssl_certificate_key /etc/ssl/example/example.key;
}
EOF

$ systemctl restart nginx

```

Your SSL certificates should be working and Nginx should be able to find them. Every request to `http://example.com` will now be redirected to `https://example.com`

Conclusion
----------

You have followed the main steps to provide a safe and stable service. Your MeiliSearch instance should be up and running, in a safe environment and ready to stay available even when the most common issues occur. In addition, it is protected by a reverse proxy with your own domain name and API key, so your data and configuration are accessible only to trusted clients. Communication with your server is now encrypted. Furthermore, its identity will be verified every time before sending sensitive data in a fast and automated manner.

You are now ready to start using your **Production-ready MeiliSearch**!

MeiliSearch in production: taking it to the next level

As a Rails and Ruby lover, I often search for the gem that will perfectly cover my use case. When I need to solve a problem I'm having, I want to choose the _right one_, the most suitable solution.

Ruby gems are extensive libraries created inside the Ruby community. The best place to find a ready solution for any task is the website [rubygems.org](https://rubygems.org/), a public repository of gems that can be searched using the search box on the home page. RubyGems’ website is an efficient tool that facilitates the sharing and the installation of packages. But although its search bar is very helpful, I decided to create an [alternative search bar](https://rubygems.meilisearch.com/) more suited to our needs.

![](https://unable-actionable-car.media.strapiapp.com/rubygemsv3_510e7b8445.gif)

The search-as-you-type experience
---------------------------------

First, I wanted to implement a search-as-you-type experience. Which means:

*   a response time lower than 50 milliseconds
*   presenting all matching results immediately under the search box while the user is typing and without them pressing enter

That is not yet the case in the RubyGems' website since a new page is loaded each time a request is made.

The relevancy
-------------

You can get relevant and accurate results by using the RubyGems' search bar, but most of the time only by performing an Advanced Search, which is not always convenient. You have to decide what to fill in the different sections. Are you going to search for a specific package by entering its name (e.g. "devise") or find a package whose summary would match a keyword (e.g. "deployment")?

However, despite this functionality, you may not find gems that meet your needs. For example, if you enter "pagination" you would expect to see the gem "kaminari", which is the most popular gem for pagination among the RoR community, showing up in the results. Here is [the return we get from RubyGem's search bar](https://rubygems.org/search?utf8=%E2%9C%93&query=pagination) when submitting the keyword "pagination". As you can see, "kaminari" doesn’t appear before the 9th result.

Even when [refining the search](https://rubygems.org/search?utf8=%E2%9C%93&query=summary%3A+pagination+description%3A+pagination), the first result to show is "kanimari-core" which is not exactly the more appropriate and famous "kaminari" package we would like to find, but it’s still better than nothing.

Then if we do a search [containing a typo in the request](https://rubygems.org/search?utf8=%E2%9C%93&query=pagintion), like "pagintion", the page is displayed without any result and suggests you a similar word for your next search.

After this experience as a user, I aimed to create **a single search bar able to understand what you want and to instantly find it**!

![](https://unable-actionable-car.media.strapiapp.com/speed_b868b434f8.jpg)

Meilisearch checks all these points, and more!
----------------------------------------------

I've never implemented a search engine; I've never even used one, except a basic Elasticsearch instance with no configuration for a proof of concept. For that reason, all I needed was an easy-to-setup tool, able to handle both speediness and relevancy at the same time. That's why Meilisearch was a perfect fit for this project.

**[Meilisearch](https://github.com/meilisearch/MeiliSearch) is an ultra-relevant and fast search engine**. In other words, it can return the most relevant results of your dataset under 50 ms, and therefore it gives a strong sense of immediacy.

Plus, without the need to configure anything, it handles search miss-spelling: i.e. Typos. Try to submit "devose" instead of "devise" and Meilisearch will return "devise" as the first result.

Finally, **Meilisearch is open-source and integrates a simple [RESTful API](https://www.meilisearch.com/docs/reference/api/overview)**. You can seamlessly communicate with the API using cURL or [one of Meilisearch's wrappers](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks).

Creating the alternative search bar
-----------------------------------

All the [gems data](https://rubygems.org/pages/data) are available on the RubyGems' website as a PostgreSQL dump file and are updated daily. Thus, I wrote a Ruby script to download the latest dataset, parse the PostgreSQL dump file, and push all the data into my Meilisearch instance. Of course, it uses the [meilisearch-ruby wrapper](https://github.com/meilisearch/meilisearch-ruby) to communicate with the API. This script is hosted in Heroku and runs every day thanks to the Heroku Scheduler.

About the Meilisearch instance, at Meili we manage an internal Kubernetes cluster, which is a handy tool to host demos like this one. For curious readers who would like to find out more, Meilisearch is quite [easy to download and run](https://www.meilisearch.com/docs/learn/getting_started/installation) by yourself (Homebrew, APT, Docker...).

Regarding HTML and CSS, I kept much of the original structure of the RubyGems' website. My intention was to develop a "search-as-you-type experience" in the same spirit as the original website. The front is deployed using GitHub Pages.

![](https://unable-actionable-car.media.strapiapp.com/chang_duong_F1_UI_4q_Dv1r_Q_unsplash_e212aa22e9.jpg)

Easily improving the relevancy
------------------------------

Without having to set anything up, Meilisearch returns pretty relevant results. Our search engine can quickly find the most suitable packages when inputting gem names like "devise" or "faraday". Unfortunately, for now it’s not always the case with keywords.

Let’s get back to my "pagination" example. If I run the search again without configuring anything, the first result to be displayed by Meilisearch will be the [Pagination](https://rubygems.org/gems/pagination) gem. I don't see [Kaminari](https://rubygems.org/gems/kaminari) at all in the results. That’s because by default, finding a document with a requested word in the title takes precedence over a document with a requested word in the description. Since there are many gems containing "pagination" in their title in the dataset, it explains why Kaminari does not appear at all.

I needed Meilisearch to include the libraries popularity as well. In my dataset, the popularity of the Ruby gems is indicated by the number of downloads. I classified my gems in eight groups of fame (downloaded more than 50M times, more than 30M, and so forth) from `0` to `7`. The latter being considered as the most famous group.

I added this information to every document (i.e. gems) as a field named `fame`. Then, I integrated this rule in Meilisearch settings as a custom ranking rule.

![](https://unable-actionable-car.media.strapiapp.com/5_519da9ed48.png)

Take a look at this snippet above. To put it simply, Meilisearch will execute one by one all of these rules (`_sum_of_typos`, `_number_of_words` ...) and sort your documents following this sequence. When I add my custom rule, i.e. `fame` in `rankingOrder` and `fame: 'dsc'` in `rankingRules`, I'm in fact asking Meilisearch to sort by fame in descendant order.

You might have noticed I have a second custom rule in the example: `total_downloads`, so that my results will be sorted by the number of downloads. But since I chose to place this rule at the end of the list, meaning it was considered less important than the other ones, it will be the last one to be applied. The order of sequence definitely matters.

I'm not going to give further details about the [Meilisearch default ranking rules](https://docs.meilisearch.com/learn/core_concepts/relevancy.html#ranking-rules), even if it’s a particularly interesting topic. Describing how our search engine works deserves indeed a separate article of its own! 😉 _Spoiler alert: Meilisearch uses a bucket sort!_

Now, if you type a [global keyword like "pagination"](https://rubygems.meilisearch.com/?q=pagination) you will find Kaminari in the first place; and if you try again with a [less famous gem name like "pagy" for example](https://rubygems.meilisearch.com/?q=pagy) you will still get the gem you expected! 🎉

Meilisearch + you = 💛
----------------------

These minor settings were really easy to integrate, and your projects might require the same kind of behavior.

Here are some useful links if you want to get ready for your own Meilisearch experience:

*   the [documentation](https://docs.meilisearch.com/)
*   the [Meilisearch's repository](https://github.com/meilisearch/MeiliSearch) on GitHub: support Meili by starring it! ⭐️
*   the [repository of this project](https://github.com/meilisearch/finding-rubygems/)

If you are interested in our project, how it works, or if you have any feedback, do not hesitate to [contact the team](mailto:bonjour@meilisearch.com)! 😁

Meilisearch finds Rubygems

Today, we are proud to share our long-term vision and the strategic priorities to be pursued in the year ahead.

But, as a first step, let me give you an overview of what we have achieved in 2019. Year One was an absolutely exciting and crazy time for us; we have been keeping busy with determining our market position. Should we limit ourselves only to large accounts, e-commerce, SaaS for start-ups and SMBs? How do we position ourselves in relation to Elasticsearch and Algolia?

In 2019 we created from scratch an **instant, relevant, and typo-tolerant search engine in Rust**, which [source code is open source](https://github.com/meilisearch/meilisearch).

We've been fortunate to work with Louis Vuitton, for whom [we integrated our engine into one of its iOS application](https://www.linkedin.com/feed/update/urn:li:activity:6516669414975291392/). We're not shy to say this application is now in production for several months and is used daily by more than 4,000 employees.

Our team also got bigger at the end of the year! [Clementine](https://github.com/curquiza) and [Charlotte](https://twitter.com/cvermandbe/) joined us as developers and took care of the documentation and SDK parts. Finally, we decided in December 2019 to get more involved in the open source community.

![](https://unable-actionable-car.media.strapiapp.com/shallow_focus_photo_of_green_potted_plant_822474_b753048259.jpg)

The open source way of life
---------------------------

We have spent a year getting to know the Search Engine Market better and identifying potential opportunities. We analyzed the companies making up the market we were targeting. What were their needs? What were our competitor's strengths and weaknesses?

To our surprise, 90% of mobile applications today have a completely inefficient search bar. And this is also true for apps from giants like Apple. Then, you may ask yourself why don't those apps use powerful search engines? Well, it is simply because of a lack of both powerful and affordable solutions. Algolia does indeed exist, but it is proprietary and requires a significant investment of money.

Many companies in the world [use technologies such as SQL databases](https://db-engines.com/en/ranking), most of the time, either MySQL or PostgreSQL, which are two of the most commonly used RDBMS. Backend developers are very familiar with them. What makes them so popular? They are both free and open source softwares, meaning that any developer can install and use them for free. And it changes everything.

Our main focus is to go open source. We want to become the reference solution in the end-user search domain. Choosing us to improve the search experience within any application or website should be the most obvious choice for developers.

Open source is not a new business concept. In the past few years, [existing companies](https://www.datamation.com/open-source/35-top-open-source-companies-1.html) proved that the open source business model can be a profitable one. There are many successful models to consider including Elasticsearch, but also MongoDB, Redis, and Sentry. Open source does not equate to making no profit and does not prevent you from having paying customers.

> Sentry has more paid customers than any other application monitoring service in the entire industry. Kind of mind blowing.
> 
> — David Cramer (@zeeg) [January 15, 2020](https://twitter.com/zeeg/status/1217546442706833413?ref_src=twsrc%5Etfw)

![](https://unable-actionable-car.media.strapiapp.com/two_brown_trees_1632790_c294309e8c.jpg)

Companies need hosted solutions
-------------------------------

The biggest concern with open source alternatives is that whereas they are easy to install and maintain, they are much harder to scale. You may potentially need to change servers, increase CPU, RAM, or add new machines to the cluster. It imposes too many constraints. That's why so many companies prefer using SaaS solutions that will carry out all these complex requirements for them. What is important is to keep in mind that the people responsible for the management of servers are scarce resources.

We, therefore, plan to release a cloud version of our search engine by the end of 2020 and ensure a simple transition from our current self-hosted version to a cloud version. We want the transition to be as smooth as possible. Imagine a "Migrate to Cloud" button that would make your application available all over the world with no latency.

Besides, our cloud solution aims to be much more complete. We are not just talking about automated server management, scalability, snapshotting, or geo-replication. We'll also offer search analytics, more comprehensive dashboards and recommendation systems. The next release will already introduce more tools and enhance the search relevancy.

![](https://unable-actionable-car.media.strapiapp.com/adventure_atmosphere_conifer_conifers_418831_8c002c9993.jpg)

Big business needs are specific
-------------------------------

Keeping data secure is a prevalent issue for large businesses in today's market. For reasons of confidentiality, such organizations can't afford to let SaaS services handle their data, or store it on servers overseas. The same goes for public and government services. Our solution is infrastructure agnostic; therefore, it can be easily installed in private cloud.

An "enterprise" plan also has to provide the basic functionalities required by large companies:

*   99.99 SLA
*   SSO
*   Single-tenant options
*   Support

All those features will be included soon enough.

The roadmap overview
--------------------

This year we'll be focusing on community and accessibility.

*   SDKs in all language ([JS](https://github.com/meilisearch/meilisearch-js), [Go](https://github.com/meilisearch/meilisearch-go), [Python](https://github.com/meilisearch/meilisearch-python), [Ruby](https://github.com/meilisearch/meilisearch-ruby), [PHP](https://github.com/meilisearch/meilisearch-php), etc.)
*   Database collectors (SQL, Mongo, Firebase)
*   Widgets for web and mobile. (VueJS, React, Android, iOS)
*   Available in popular marketplaces (Wordpress, Gatsby, Magento, Prestashop, etc.)

Documentation and telling examples will be part of all these integrations and SDKs. Demonstration videos will give you an insight on how to use our search engine in different use cases.

The next features you should expect to see in 2020:

*   [High availability](https://github.com/meilisearch/MeiliSearch/issues/410)
*   [Schemaless](https://github.com/meilisearch/MeiliSearch/issues/422)
*   Facetting, categories
*   A dashboard
*   Search by geolocation
*   Search by date proximity
*   A GRPC interface

Last but not least, we are thrilled to announce you that a brand new website will also be launched at the beginning of the year.  
Do not hesitate to leave us a message and give us your impressions. Let's have a chat, or let's meet! If you like what we do, feel free to share our project and star the [Meilisearch project repository](https://github.com/meilisearch/MeiliSearch).

To open source, and beyond!

We are proud and thrilled to present our [open-source search engine](https://github.com/meilisearch/MeiliSearch). After one year of hard work, we are finally able to make our first official beta release.

We want to contribute to the open-source community by offering an ultra-relevant & instant search engine to improve the search experience in every application.

Meilisearch is the **first open-source instant search engine**. Instant means that our search engine is so fast to answer that you have the search-as-you-type experience - results are appearing and reordering on each keystroke.

![](https://unable-actionable-car.media.strapiapp.com/crates_io_demo_907b54a599.gif)

Meilisearch finds crates on [crates.meilisearch.com](https://crates.meilisearch.com)

We differ from other open-source search engines in many ways.Compared to Elastic Search (and other Lucene-based engines), we specialize in end-user search, and Meilisearch works out-of-the-box to that end. Compared to your database search engine, we are more relevant and way faster. We have typo-tolerance, and it works ;)

Motivations
-----------

We built Meilisearch with the end-users in mind, to reduce the friction between the user and the machine when using your app, browsing your website.

> You should not be Amazon or Google to have a good search engine.

It seems unfair to us that today, only the biggest companies could afford the luxury of a decent search engine. From the biggest corporations to your Sunday side-project, you should have a go-to search engine that does not cost you an arm and a leg. You should not need the financial means of Google or Amazon to afford that.

![](https://unable-actionable-car.media.strapiapp.com/photo_1571924035778_d53e10ef9858_dc0da161e2.jpeg)

Team
----

At the start, we were three developers. And because a developer knows how to recognize another good developer, we hired two other developers. Today, we are a team of five working on the engine, SDK's, front-end libraries, [documentation](https://docs.meilisearch.com/), articles, and social media.

How did we survive at 5 in Paris for one year, you may ask. Well! We participated in a Hackaton about search organized by Louis Vuitton. At that time, we were already working on our search engine, and it seemed to be a call of destiny. We finished first!

Our winning price was three Louis Vuitton bags 👜, and then, as a little bonus, we signed a contract with them to develop our product and run it in production on their servers.

![](https://unable-actionable-car.media.strapiapp.com/Hackaton_920e7ba818.jpeg)

What's coming next
------------------

We will continue to work on the search engine to make it faster and more relevant than ever and adding features such as geolocation or trendiness. We will work on different APIs wrapper and front-end libraries to make Meilisearch more and more accessible. In a few months, we may even offer our search engine as a service to free you from the hassle of maintaining your infrastructure.

If our story inspired you, please give a try to our search engine. You can follow the quick start and read more about how it works in the documentation. If you want to support us, you can star the project on Github.

![](https://unable-actionable-car.media.strapiapp.com/tenor_1_c11a2fa59b.gif)

Ressources
----------

*   [Documentation](https://docs.meilisearch.com)
*   [Github](https://github.com/meilisearch/MeiliSearch)
*   [Twitter](https://twitter.com/meilisearch)

Meilisearch: Beta release!

Today, I am about to guide you in the depths of crates.io and how [I made an alternative search bar](https://crates.meilisearch.com) using our instant search engine: [Meilisearch](https://github.com/meilisearch/MeiliDB).

![](https://unable-actionable-car.media.strapiapp.com/crates_io_demo_798a562ddd.gif)

The Meili instant, relevant, and typo-tolerant search engine

[Crates.io](https://crates.io) is the official website that stores Rust community crates (packages), and it's the place where the cargo package manager uploads, updates, and downloads those.

[Sean Griffin](https://twitter.com/sgrif) is part of the crates.io team and maintains the current search engine of it along with the whole website. [Kornel Lesinski](https://kornel.ski/) built [lib.rs](https://lib.rs/) an alternative to [crates.io](http://crates.io/) and uses [Tantivy](https://github.com/tantivy-search/tantivy/) to power its search bar. To be honest, I prefer its color design, that's why I took it for our search demo.  
  
I decided to run our instant search engine and test its relevancy overtime against these existing solutions. Our search engine uses completely different algorithms; it is based on prefix search and is typo tolerant.

![](https://unable-actionable-car.media.strapiapp.com/current_results_1_73457862c1.png)

Meili is typo-tolerant and supports a whole lot of other features

So, I asked myself: Why not use our new instant search engine and make it useful to my beloved community? It would give us lots of feedback and probably some pull requests during the process.

* * *

At Meili we manage an internal Kubernetes cluster, this is useful to host demos for clients. The Meilisearch server for this demo currently run on a pod in this cluster.

To make Meilisearch exhibit those crates, we needed to find all the currently available packages on crates.io. Fortunately, this index is available on GitHub in the form of several subfolders with the names and versions of the packages, containing something like _32 000_ files. A commit is done each time a crate is updated to a new version, or a version is yanked.

So, I used the [crates.io-index repository](https://github.com/rust-lang/crates.io-index) to **initialize** our newly created Meili search engine but needed more data first, like, the description, keywords, and categories of each of those crates. Again, the Rust crates.io team was here for us, I talked to [Pietro Albini](https://twitter.com/pietroalbini), and he pointed me to the not rate-limited servers that deliver packages content.

Now that we can retrieve useful data, I create an [async crawler](https://github.com/Kerollmops/meili-crates/blob/67770fe179436eee6478cdebff7d8613f9263049/src/lib.rs) that downloads, extracts, retrieves the Cargo.toml, and upload the essential data to Meilisearch.

![](https://unable-actionable-car.media.strapiapp.com/Screenshot_2019_11_08_Meili_Dashboard_c9d2ae42f1.png)

The Meili dashboard interface showing raw documents

Meilisearch now understands that data and gives us instant, relevant and typo tolerant responses. But, what about new crates? We want to be notified about new crates and be able to send those to Meilisearch.

[Docs.rs](https://docs.rs) is the official website to compute and store the documentation of all the Rust packages hosted by crates.io. It diffs the crates.io index each minute to know about new crates updates. Luckily, it provides an Atom feed of those updates.

It is where [Heroku](https://heroku.com) enters the game. Heroku offers something like _1000_ free hours per month of computing power on their servers and provides us schedulers. We can consume those credits and freely [ask docs.rs about newly updated crates](https://github.com/Kerollmops/meili-crates/blob/67770fe179436eee6478cdebff7d8613f9263049/src/bin/live.rs), every 10 minutes, by fetching the Atom feed, download the updated packages like previously, and finally update our search engine, **live**!

![](https://unable-actionable-car.media.strapiapp.com/heroku_live_timings_1_fbb7661c94.png)

Fetching new crates takes us 4 seconds

Search results were satisfying but not as expected, there was something wrong. When we wrote "serde", for example, the first result was relevant, but the next ones were not. It was related to the fact that Meilisearch did not have enough data to rate crates except the query matching words.

![](https://unable-actionable-car.media.strapiapp.com/Screenshot_2019_11_10_Meili_crates_browser_2000_1_5cfc7e603c.png)

Meilisearch doesn't know how to settle equal crates with only the matching words

**Downloads counts** amazingly improved the search results. [This data is available through crates.io](https://crates.io/data-access). A full database export is done each day, and it contains the number of downloads of each crate. I decided to use those as the last ranking criterion to help Meilisearch settle about crates considered equal.

![](https://unable-actionable-car.media.strapiapp.com/Screenshot_Meili_crates_browser_2000_good_1_21f3eb0098.png)

Meilisearch shows better results thanks to the number of downloads

I deployed a Heroku scheduler to run each day to update all the crates downloads; it takes something like 30 seconds to download the tarball, extract it, read the CSV and upload the _32 000_ crates downloads counts to Meilisearch. So we are far from _1000_ free hours per month.

* * *

I think this search demo is pretty good, but I also thought about adding synonyms and stop-words as Meilisearch supports those. For example, it would be pleasant to write "db" and see results associated with "database". Stop-words would help ignore useless words like "the" or "that" which could pollute search results sometimes, but we need to be careful as crates names could be composed of stop-words.

Meilisearch also supports basic filtering, and it would be great in the future to be able to search for crates in a category or with a specific keyword.

All these improvements can be made by you; [the demo is open source](https://github.com/Kerollmops/meili-crates). The [core engine source code](https://github.com/meilisearch/MeiliDB) is also available on GitHub, that's the whole point of this article! Take a look and talk about it, more people involved, more features!

Search for Rust crates with Meili

SpO₂ is oxygen saturation and is used in medical person monitoring.

I am Kerollmops, I am the CTO of [Meili](https://www.meilisearch.com/) and today I am releasing [SpO₂](https://github.com/Kerollmops/spo2/).

At Meili, we needed a tool that allows us to monitor our pods, we already have [vigil](https://github.com/valeriansaliou/vigil) which health checks our front page and backend, but the number of these services is limited. We do not pop new front or backend servers dynamically (for now). When we create new search engines for the user we instanciate a kubernetes pod, we need to monitor the health of this service. Adding each of those URLs by hand in the vigil config file is not a solution.

So we decided that we needed a simple tool, a tool that can accept HTTP requests to register/unregister URLs to health check. We use the [new async/await Rust syntax](https://blog.rust-lang.org/2019/09/30/Async-await-hits-beta.html) along with [tide](https://github.com/http-rs/tide) for the http server, no big deal here.

Our current cloud provider is [Digital Ocean](https://www.digitalocean.com/), therefore, we cannot host our SpO₂ service there. We chose [Scaleway](https://www.scaleway.com) as it is way cheaper, and it works out of the box. We need persitent storage of the health checked URLs. What would you do if those are only stored in RAM? What if the server restarts? I already worked on [a disk backed key-value store in Rust named Sled](https://sled.rs/). So we chose to rely on it.

![](https://unable-actionable-car.media.strapiapp.com/screenshot_d586f10f06.png)

[@qdequele](https://quentin.llmops.com) built the front-end with vanilla javascript. Using Websocket we are able to display in realtime the pods status. As most humans do not stand in front of a TV the whole day, spotting color changes to notify the devops, we decided to implement notifications. We are using Slack for all of our monitoring tools, and because it is as simple as a webhook to implement, we went with it.

In the last release, we made some improvements to the Slack notification system. We now batch status changes events by 40; this means that SpO₂ sends one message with at most 40 events and regulates channel spamming. It also displays the HTTP status related to an unhealthy measurement and the error message on an unreachable one.

SpO₂ does not support SSL/TLS by itself, neither for the HTTP nor the WebSocket endpoints. We needed this kind of security so we looked at NGINX, a tiny little obscure reverse proxy server which we configured with basic authentication. It is not an easy task and because we are cool we made the documentation to help you do the same.

Do not hesitate to share or star this project, pull requests are welcome 😊

And just as a side note, we do not measure humans but machines actually.

SpO₂ the little dynamic monitoring tool

We want to share our thoughts about open source and how we should license our code. This is entirely new to us, and we are still figuring out the best solution and opportunities so if you have any reading recommendation do not hesitate to tell us.

As a quick reminder: at Meili, we are building [an instant search engine](https://github.com/meilisearch/MeiliDB), in Rust 🦀, and we want to open source it. We are still wondering about the right business plan for us, and we may write about it too but the subject of the day is license!

Why did we choose to go open source?
------------------------------------

We believe that every application deserves a decent search engine. That means that search engine technology should become a commodity. We found a sweet spot between Algolia which is very developer-friendly but proprietary and Elastic Search which is difficult to set up for an instant search.
  
We think that if you want to become the standard technology in your field, you should be open source, that way you get to build your features with the people who use it and you gain trust around your code. Also, because we are cool developers, we are using a lot of open source code, and we want to give back by contributing to open source and also sharing our projects.

What is open source?
--------------------

Open source is complicated, and if you ask two persons a definition of open source, you may realize that there are many definitions of open source. [Steve Klabnik wrote a very interesting blog post](https://words.steveklabnik.com/the-culture-war-at-the-heart-of-open-source) about the culture war at the heart of open source in which we learned about open source history and why people are fighting over its definition.

In the beginning, there was the Free Software Foundation, which was created in 1985. The FSF was founded by Richard Stallman to support the GNU Project and the concept of Free Software: the idea that software should be free to use, free to copy it and free to redistribute it. However, the term Free is very restrictive. For the FSF, a Free Software must be under a copyleft license. Copyleft implies that all the work deriving from it must also be copyleft. We call this a “hereditary” or “contaminating” license, and we quickly understand that this kind of license could scare businesses.

Then there was the Open Source Initiative, a non-profit organization created in 1998. Eric S. Raymond and Bruce Perens wrote the Open Source Definition which frames less restrictive licenses (MIT, Apache, BSDs, etc.). These licenses all require to credit the author of the software you are using, but what you are building can have any other license. One of the goals of this Open Source Definition was to be more "business-friendly" because the term "Free" could scare companies, and by having a more friendly name and less restrictive licenses you can encourage companies to invest and participate in open source.

* * *

To illustrate the differences, we can take two OS based on Unix: On one side there is the Linux kernel which is licensed under the GPLv2 (copyleft), and this is why Linux-based Android is open source. On the other hand, there is Berkely Software Distribution (BSD) which is licensed under the BSD license, and its most famous fork are iOS and Mac OS which are proprietary and private.

These are today's definitions of open source, and the problems are:

*   Everyone does not agree on one definition because everyone has its ideology of open source
*   Everyone does not play by the same rules: while some companies are releasing their GPL's licensed projects on some obscure FTP, others are releasing their code publicly on GitHub without an OSI approved license. What is open source to you?

Open source nowadays
--------------------

As you may have read in the last months, some "open source" projects changed their license for the same reasons. We think that [MongoDB explains it very well](https://www.mongodb.com/licensing/server-side-public-license/faq#what-we-sell):

> This is a time of incredible opportunity for open source projects, with the potential to foster a new wave of great open source server-side software. The reality, however, is that once an open source project becomes interesting, it is too easy for large cloud vendors to capture all the value but contribute nothing back to the community.

And they are not the only project worrying about this situation.

Redis, for example, [is licensing some of its Redis Modules under its own license](https://redislabs.com/blog/redis-labs-modules-license-changes/), the Redis Source Available License. They were previously using the Commons Clause over an Apache license. The Commons Clause adds some restriction on commercial distribution over an already existing license like the Apache one. But [they changed it for confusion reason](https://www.zdnet.com/article/redis-labs-drops-commons-clause-for-a-new-license/); people were not sure whether it was open source or not.

[Confluent changed its license too](https://www.confluent.io/blog/license-changes-confluent-platform), from Apache they choose to create the Confluent Community License because they were afraid of some big cloud companies too.

Open source and Meili
---------------------

The point is not about whether big companies should contribute more or differently to open source but that open source is evolving, and we need a new definition, a new term to gather around and know what we are talking about.

Maybe we need labels to define and frame the ideology we are supporting as a company? Perhaps we need a patent-style system which states that every code that you release as a company will be under the MIT License or any other license 3 years after you wrote it. This way you could monetize your code for a period while enabling public disclosure of your code?

At Meili, we do not have a clear vision on these issues yet, but we are thinking about it a lot. We want our code to be available to anyone, free to use it and modify it for your projects. If you're going to use it for some personal project, go for it, if you want to use it for your company you should too. We do not wish to any cloud provider to git clone our project and be a competitor on a SaaS offering. Because we believe that our project will thrive more if we can build a sustainable business on it.

Today [our code is still under the MIT license](https://github.com/meilisearch/MeiliDB/blob/master/LICENSE), but tomorrow we might change it for the Commons Clause or write our public license as MongoDB and Confluent did. No, it won't be open source as the OSI state it, but we believe that making a publicly available source code is still better than closed source, too bad there is not a clear term of it today.

Meilisearch latest news and company updates