We're halfway through Hacktoberfest, an excellent time to look back and see how much we have accomplished so far. It's also an opportunity to recenter ourselves for the next couple of weeks and conclude this event with a bang.

We're incredibly proud to share that, so far, we've merged 92 pull requests! We're baffled by our contributors' enthusiasm and involvement. We wish to extend a warm thanks to everyone who participated.

And to express our gratitude, we'd like to share our plans for additional Meilisearch swag and common goals, as we teased in our previous Hacktoberfest [blog post](/blog/contribute-hacktoberfest-2022/)*Meilisearch exclusive swag**
------------------------------

Last year, we sent reusable bottles and some stickers to our contributors. When it came to shipping, it was not all smooth sailing, but we learned a lot from it and have adjusted our strategy this year.

We had settled on reusable bottles in the spirit of eco-friendly and reusable gifts. These values are fundamental to us as we wish to offer goods people can reuse for a long time. Given that most  of our contributors are developers, we've considered that tech-related presents might be particularly appreciated. This is how we came to our current choice.

We're very excited to be able to give all participants a swag box containing a duffle bag, a webcam cover, as well as a touchscreen tool shield.

![Picture of the swag box products such as a dark duffle bag, a black webcam cover, a white touchscreen](https://unable-actionable-car.media.strapiapp.com/Untitled_design_6_1f6a37b53c.png)

(This isn't the final design of the goods you'll receive :) )

The touchscreen will ensure you won't have to touch public surfaces and keep your hands germ-free. The webcam cover will guard your privacy. And finally, you'll be able to put all your gifts in your snazzy duffle bag-both, a fashionable _and_ green choice.

If you've had one of your PRs merged or will get one merged before the end of Hacktoberfest, you're eligible to receive your box! Our maintainers will share a link to a simple online form where we will collect the information we need to start the redeeming process.

**Common goals** 
-----------------

As we did [last year](/blog/hacktoberfest-2021-recap/)e strive to not only contribute to the open-source community throughout Hacktoberfest but also hope to pay it forward. This is why we come back again with some collective goals to benefit a greater mission.

For Hacktoberfest 2021, we donated to open-source maintainers, climate activist groups, and groups that support diversity in tech.

This year, we identified local groups that might benefit from our contributions and with whom we hope to foster a closer relationship. We'd love to see how our donations -achieved thanks to you!- will impact their work.

These are the different groups we plan on supporting this year:

### **Group 1. Diversity in tech**

Diversity in tech is, now more than ever, a hot topic. We strive for a world where diversity isn't a debate topic but a simple reality. Within Meilisearch, we do our best to encourage inclusion and acceptance, and we are very grateful for the opportunity the diversity our mostly remote team offers us.

This is why we wish to keep supporting such topics through the following associations:

👩🏿‍🦱 [Women on Rails](https://women-on-rails.github.io/ressources/) - This LGBTQ+-friendly association works hard to support women that want to practice coding on Ruby and Rails, specifically.

👩🏾‍💻 [Ladies of Code Paris](https://ladiesofcodeparis.netlify.app/) - This Paris-based group supports women's careers in tech.

👥 [Becometech](https://becomtech.fr/en/why-support-us/) - Once again, this Paris-based group strives for inclusion and diversity in IT.

### **Group 2. Climate activism**

As a tech company, we are aware of our carbon footprint. To further our efforts in minimizing this impact, we wish to continue to support some climate activist causes such as:

🌊 [Seasheperd France](https://seashepherd.fr/) - This group works on protecting oceans and raises awareness against aggressive fishing practices.

🌏 [Teragi](https://www.teragir.org) - This association supports sustainability projects through five different active programs

🌴 [Reforestaction](https://www.reforestaction.com/nos-solutions-pour-les-entreprises) - This group pushes hard on reforestation efforts.

### **Group 3. Societal organizations** 

Finally, our third group this year tackles social issues. The members of Meilisearch hope to leave this world in a better state than we found it. In these uncertain times where it's so easy to feel divided, we wish to stand together and support the following groups:

👭 [MAS les Sophoras , Unapei Alpes Provence](https://annuaire.action-sociale.org/?p=mas-les-sophoras-130008402&details=caracteristiques) - This French, Marseille-based, association supports disabled adults throughout their lives by helping integrate them into society.

🇺🇦 [Urgence: santé des femmes Ukrainiennes](https://www.helloasso.com/associations/asf-actions-sante-femmes/collectes/urgence-femmes-ukrainiennes) - This group supports Ukrainian women's health who had to flee their country due to the war, especially with pregnancies.

👫 [Perce neige](https://www.perce-neige.org/) - This Marseille-based group works on supporting mentally handicapped adults. 

**How to unlock the donations?**
--------------------------------

This year, the sky's the limit! It will take 50 PRs to go from one stage to the other, meaning each merged PR represents 10€ of donation.

![Picture displaying the 4 goals we hope to achieve with the appropriate monetary donation next to each goal. ](https://unable-actionable-car.media.strapiapp.com/Goal_1_a57a68e5ff.png)

To calculate the total number of contributions, we will count the number of  Hacktoberfest-related pull requests merged in Meilisearch repositories at the end of the month. We will also consider any PRs tagged with the “Hacktoberfest-accepted” label but have not been merged.

As we mentioned, we've already merged 92 PRs we're happy to announce we've already achieved the first goal on our list! Each of our three groups will be receiving 500€, and that's thanks to your efforts! Let's work hard to bring these donations to the next level by smashing through the rest of our goals.

### **How to participate?**

You still have time to participate for a chance to get your hands on our exclusive swag box and help in achieving our common goals!

You can find all our repos accepting Hacktoberfest contributions [here](https://github.com/search?q=org%3Ameilisearch+topic%3Ahacktoberfest&type=Repositories); alternatively, all our Hacktoberfest-eligible issues are [here](https://github.com/search?q=org%3Ameilisearch+label%3Ahacktoberfest&state=open&type=Issues).

There is an issue for everyone, with plenty of [good first issues](https://github./blog/2020-01-22-how-we-built-good-first-issues/) for more novice contributors and more challenging topics for our seasoned devs.

Here are our suggestions for repos that contain some interesting good first issues:

*   If you're a language expert, you'll find many issues in [Charabia](https://github.com/meilisearch/charabia) that require your knowledge of the language to improve our tokenizers and make it easier for Meilisearch to process foreign languages. 
*   Our [PHP](https://github.com/meilisearch/meilisearch-php) integration also offers some issues you might be able to tackle without too much trouble if you're interested.
    

And, of course, if your PR is not associated with an issue, but gets accepted, we'll be happy to tag it as "Hacktoberfest accepted", so don't let that stop you!

### **Join our community!**

Our [Slack community](https://join.slack.com/t/meilicommunity/shared_invite/zt-1g4juofj9-FAc_X_A_Ka8EJ6hUMauQCA) is always open to new members! We have a #[hacktoberfest](https://meilicommunity.slack.com/archives/C02G1H43J2X) channel where both Meilisearch employees and fellow contributors mingle, so don’t hesitate to join us if you’d like.

We look forward to your feedback on yourHacktoberfest experience.

Hacktoberfest 2022: Mid-October update

With Hacktoberfest in full swing, contributors and maintainers alike are busier than ever. But this month is not only about writing code and opening PRs—it is also about connecting with people and becoming part of a community. We would like to take this time to share a Hacktoberfest story that’s very dear to us. 

Meet [Bruno Casali](https://meilisearch.notion.site/Bruno-Casali-49a83569f1e54ba1b3276e257ff4d165), Meilisearch’s very own Integrations Team Lead! Bruno was scouted last year following his participation in Hacktoberfest, going from occasional external contributor to a key Meilisearch employee. He kindly agreed to share his thoughts and experience with us.

![Portrait of Bruno Casali](https://unable-actionable-car.media.strapiapp.com/rsz_1rsz_05_1_c1b1d3380e.jpg)

Contributing to Hacktoberfest
=============================

First of all, it’s important to know last year wasn’t Bruno’s first rodeo. 

_“I have participated in Hacktoberfest since 2016 (the second year). I have always been that developer who tries to find good repositories to contribute to, and suddenly, with Hacktoberfest, I could be rewarded in some way for doing that. I immediately saw it as an opportunity to meet people from different countries making contributions to open-source and found out it was also a way for me to validate my programming knowledge.”_

We were curious to hear about what made Hacktoberfest such a peculiar time of the year for the participants. He explains to us that the atmosphere is very different, for both maintainers and participants, who are 100% focused on their objectives:

_“You can expect a lot of activity in your repositories (sometimes even 20x more than usual) and meeting people from around the world. Big projects receive even more attention. It’s a good time to show up and do great things: not only can you learn a lot, but maybe the people you’re collaborating with can see you as a potential employee.”_ 

When it came to his favourite part of Hacktoberfest, Bruno was emphatic: it was all about connecting with the community. _“I enjoyed Hacktoberfest for many reasons. It was a time to meet new people (mostly people from outside of my native country) and show I'm a good developer. It was also an opportunity to create a portfolio for my work.”_

Communication is not always easy nor smooth, though: 

_“Unfortunately, some maintainers neglect communicating with contributors. Sometimes honest attempts at solving an issue are completely ignored and this represents for me the worst possible thing. Because I, as a contributor, am not paid for that work. I invested my time and I expect something in exchange, even if it is just a ‘hey, you did it wrong’ so I can learn from that experience. And of course I don’t get that if the maintainers just disappear.”_ 

Which is a very good reminder for us maintainers to respect the time and energy invested into our projects by Hacktoberfest participants.

![Hacktoberfest x Meilisearch crossover logo](https://unable-actionable-car.media.strapiapp.com/Frame_9_4389751892.png)

From contributor to maintainer
==============================

We were of course interested in knowing how Bruno found Meilisearch and why he decided to contribute:

_“Hacktoberfest 2021 was the first time I heard about Meilisearch. I was looking for projects offering extra swag for contributors and found Meilisearch in a [random list](https://hacktoberfestswaglist.com/list/#meilisearch) out there. I checked if they had any repositories I could contribute to and found the [Ruby](https://github.com/meilisearch/meilisearch-ruby) and [Ruby on Rails](https://github.com/meilisearch/meilisearch-rails) integration repos.”_

A lot of repositories take part in Hacktoberfest, so we wondered: how was working with the Meilisearch team when compared to other companies?

_“The first contact was amazing! The Integrations Team answered quickly, so it made me want to keep contributing, because I felt I was part of the project, that Meilisearch was a place where I could actively make a difference. It was a very positive experience and I could feel that Meilisearch was different.”_

This eventually led to an unexpected (but very pleasant) surprise:

_“Then, 10 days after my first contribution, [Morgane Neff](https://meilisearch.notion.site/Morgane-Neff-ce9c8e7d86ab46a6bdd64b3164bbec25), Meilisearch’s HR Manager, reached out to me with a job offer. I was quite surprised about that, because I've never had that kind of response to one of my contributions before, I felt amazing.”_

One year later, we asked Bruno to reminisce on his transition and if the change from participant to employee was an easy one.

_“I maintain my own open-source projects, so in some aspects the transition was easy. Something I was not used to was dealing with interpersonal conflicts during code reviews. Other situations can be a bit awkward, like external users complaining about something in our repositories. Also, my role at Meilisearch is to manage the Integrations Team, which means I'm responsible for 30+ repositories with multiple tech stacks. Keeping on top of each one of them requires a lot of context-switching, which can be difficult.”_

Open-source ♥️ 
===============

In the end, Bruno says, the secret to a great Hacktoberfest experience is very simple:

_“Love the process of contributing to open-source, love the idea of meeting people who can teach you, love the idea of teaching others through your own contributions. You have nothing to lose and everything to gain by doing that._

_“And, if you want to work for an open-source company, you can see your contributions as a coding test. Do your best, be kind with the maintainers—rinse and repeat 😊”_

We are super grateful to Bruno for sharing his experience! We hope his story can motivate anyone out there wondering whether they should get involved in open-source development. If you wish to contribute to Meilisearch during Hacktoberfest and get some of our exclusive swag, find all our Hacktoberfest eligible issues on [Github](https://github.com/search?q=org%3Ameilisearch+label%3Ahacktoberfest&state=open&type=Issues) and check out our dedicated #[hacktoberfest](https://meilicommunity.slack.com/archives/C02G1H43J2X) channel on Slack.

And again, to all Hacktoberfest participants: good luck and keep up the great work!

  
  
  

=========

Hacktoberfest stories: from contributor to manager

Meilisearch v0.29 is out and comes with a new feature: matching strategy customization!

Consider the following situation: a user sends a two-word search request. What happens when there are not enough documents to meet the requested `limit`? Should the engine only return documents with all the query terms? Or should it return more documents? If so, which criteria should it apply to return them?

That’s where  matching strategies come in. A matching strategy is used to match query terms when the engine has not found enough documents containing all query terms. It’s not an easy decision to make, and it’s highly dependent on the type of data the user is searching for. Fortunately, now you can choose the strategy to apply at search time 🎉

**A little bit of history**
---------------------------

Back in 2021, all versions pre v0.21 only returned documents where all the query terms were present. So if I searched for “Peter Parker”, it would just return documents in which both terms —“peter” and “parker”— were present. This matching strategy is called: `all` because **all** query terms must be present in the document for it to be returned.

![You're welcome GIF](https://unable-actionable-car.media.strapiapp.com/image_8205358452.gif)

[Ranking rules](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#ranking-rules) are one of Meilisearch’s most important features for  ensuring relevant results. The _[words](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#1-words)_ ranking rule states the following:

Results are sorted by decreasing number of matched query terms. Returns documents that contain all query terms first.

This rule had been lying around in our documentation for a while, coupled with the following warning message:

For now, it is mandatory that all query terms are present in returned documents. Therefore, this rule does not impact search results yet.

With v0.21, the words rule started working, so this warning disappeared with the all-query-terms-present constraint.

From that point on, if there were not enough documents containing all query terms, Meilisearch removed one term at a time, starting from the end of the query. So if I searched for “Peter Parker”, it would first return documents in which both terms were present, followed by documents with just “Peter”

This type of matching strategy is called `last` because Meilisearch removes the **last** term of the query.

![Nailed it GIF](https://unable-actionable-car.media.strapiapp.com/image_1_533740ccdb.gif)

It turned out that many users were pretty content with the previous matching behavior. Unfortunately, this change did not allow them to migrate to a newer version of Meilisearch, which prevented them from benefiting from its many improvements: sorting at search time, geosearch, granular API keys rights, multi-tenancy, etc. Not only were they missing all that, but they were going to miss all the awesome features to come! 😱

Don’t panic! Version 0.29 has come to the rescue!

**Closing the feedback loop**
-----------------------------

Now, it’s possible to choose your desired matching strategy at search time. The default strategy is `last`; if you want to use `all`, all (wink wink) you need to do is specify it in the search body as follows:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "peter parker", "matchingStrategy": "all" }'
```

This feature has been in the works since September 2021, when [Guillaume Mourier](https://github.com/gmourier/), our Product Manager, started the [“Policy for matching query words” discussion](https://github.com/meilisearch/product/discussions/255) to collect feedback on the matter. We would like to thank everyone involved for taking the time to share their input 🙏 Meilisearch would not exist as it does today without the support from our community 🥰

There are as many reasons to use either strategy as there are many use cases. Not sure yet which one to choose? I’ve created a demo so you can test both strategies to help you make up your mind 😊

<Callout>
  For more in-depth information on matching strategy customization, you can read the [dedicated section](https://www.meilisearch.com/docs/reference/api/search#matching-strategy) of the documentation.
</Callout>

**The demo**
------------

This demo uses the [movies dataset](https://www.meilisearch.com/movies.json), used in Meilisearch’s [quick start guide](https://www.meilisearch.com/docs/learn/getting_started/quick_start) and widely throughout the [documentation](https://www.meilisearch.com/docs).

I have made no changes whatsoever to the settings. I have simply indexed the dataset and have kept the default configuration. Pure as the driven snow ❄️

When performing a search, you can click on the button to modify the `matchingStrategy` search parameter and see the different results depending on the strategy used.

Try it here 👉 [matching-strategy.meilisearch.com](http://matching-strategy.meilisearch.com)

If you lack ideas or need some inspiration for query terms, I have listed some query ideas, ranging from 2 to 10-word queries:

*   forrest gump
*   big fat liar
*   return to never land
*   the purple rose of cairo
*   the curious incident of the dog in the night time

![When searching for "the hateful eight", Meilisearch finds 28412 results with the "last" matching strategy versus one result with the "all" matching strategy](https://unable-actionable-car.media.strapiapp.com/matching_strategy_488f3d6b7a.gif)

**Conclusion**
--------------

I hope this demo has helped you better comprehend the differences between the two strategies and their impact on search results. As usual, you can find [the code on GitHub](https://github.com/meilisearch/demos/tree/main/src/matching-strategy).

There are numerous ways of fine-tuning the relevancy of your search results. This is just one of the many options available. We know every project is different and has its own requirements; that’s why your feedback is so important to us. We work to make it easy to customize your instance so that you can deliver the best search experience to your users.

Don’t hesitate to check our [product repo](https://github.com/meilisearch/product/discussions) and make a suggestion or join an existing discussion on improving the product.

If you like Meilisearch and want to support us, a star on [GitHub](https://github.com/meilisearch/meilisearch) means a lot 😇

Are you returning the search results your users want?

This article looks at some of the main changes in Meilisearch’s latest release. For more details, [read the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.29.0).

New feature: matching strategy
------------------------------

v0.29 introduces a new search parameter: `matchingStrategy`. This parameter lets you define, at search time, how Meilisearch should match query terms:

*   `last`: returns documents that contain all query terms first. Additional results are then retrieved by decreasing number of query terms present in a match: Meilisearch will remove one query term at a time, starting from the end of the query, and include any new matches to the list of results. This has been the behavior since v0.21 and will remain the default strategy.
*   `all`: only returns documents containing all query terms.

Example:

```bash
curl \\
  -X POST '<http://localhost:7700/indexes/movies/search>' \\
  -H 'Content-Type: application/json' \\
  --data-binary '{ "q": "american ninja", "matchingStrategy": "all" }'

```

With the above request, Meilisearch will only return documents containing both "american" AND "ninja".

We hope this new feature will encourage those still working with v0.20—the last official Meilisearch release using an `all` matching strategy by default—to update to our latest release and benefit from the new features introduced since then: [sorting](https://docs.meilisearch.com/learn/advanced/sorting.html#sorting), [geosearch](https://docs.meilisearch.com/learn/advanced/geosearch.html#geosearch), [granular API key rights](https://docs.meilisearch.com/reference/api/keys.html) and many more! If you’re still on v0.20 and don’t think you will upgrade just yet, we’d be [happy to know](https://docs.meilisearch.com/learn/what_is_meilisearch/contact.html#contact-us) what’s refraining you.

You can test this feature with the [matching strategy demo](https://matching-strategy.meilisearch.com/), and learn more about it in the [dedicated blog post](/blog/matching-strategy/)mprovement: indexing performance
---------------------------------

We have sped up indexing, especially for the following operations:

*   Facet indexing: we have modified the algorithm to increase the indexing speed of filterable attributes
*   Document deletion and update:
*   We have introduced **soft deletion.** This is a technique in which a flag is used to mark data as deleted, rendering it inaccessible to all users without actually removing it from the database. Documents are deleted at a later date, before they take up too much space on the device. Thus, the time taken to delete records on disk is postponed and doesn’t delay the indexing process.
*   when reindexing, Meilisearch now detects if the exact same version of the document already exists and, if that is the case, does not index it again

### Behavior change: auto-batching

In v0.26, we introduced an experimental feature: auto-batching. When activated, auto-batching automatically combines consecutive document addition requests, significantly speeding up the indexing process.

We are happy to announce auto-batching is now the default indexing behavior and no longer experimental  🥳

This means you don’t need to use the `**--enable-auto-batching**` CLI flag to enable it anymore. Using `--enable-auto-batching` will now throw the following error:

```bash
error: Found argument '--enable-auto-batching' which wasn't expected, or isn't valid in this context

	Did you mean '--disable-auto-batching'?

	If you tried to supply `--enable-auto-batching` as a value rather than a flag, use `-- --enable-auto-batching`

USAGE:
    meilisearch --disable-auto-batching

```

The following auto-batching customization options have also been removed and will throw errors if used, so make sure your application is not using any of them before upgrading to v0.29:

*   `--debounce-duration-sec`
*   `--max-batch-size`
*   `--max-documents-per-batch`

If you hadn't activated the auto-batching feature, you have nothing to do but enjoy the increased indexing speed 🏎️

🧐 You may have noticed it in the error message above: if for some reason you do not want Meilisearch to automatically batch requests, a new CLI flag is available to deactivate this feature: `--disable-auto-batching`.

<Callout>
  We are continuously working on improving our search engine, and your feedback is essential. If you experience any issues with document indexing speed, we would be very grateful if you could let us know in this [discussion](https://github.com/meilisearch/meilisearch/discussions/2131).
</Callout>

Improvement: filters
--------------------

We have added two new filter operators: `IN` and `EXISTS`

*   The `IN` operator selects all documents whose specified field contains at least one of the given values
*   The `EXISTS` operator checks for the existence of a field. Beware that fields with empty or null values still count as existing

Given the following book dataset:

```json
[
  { "id": 1, "title": "Pride and Prejudice", "genres": ["romance"] },
  { "id": 2, "title": "Le Petit Prince", "genres": [] },
  { "id": 3, "title": "Alice In Wonderland" },
  { "id": 4, "title": "The Hobbit", "genres": ["adventure", "fantasy"] },
  { "id": 5, "title": "A Game of Thrones", "genres": ["fantasy"] },
]

```

The expression `genres IN [fantasy, adventure]` will return documents `4` and `5`.

The expression `genres EXISTS` will return documents `1`, `2`, `4`, and `5`.

Both operators can be combined with the  `NOT` (`!=`) operator.

### Behavior change: **`!=` (`NOT`) filter operator**

The `!=` (`NOT`) filter operator returns documents that do not satisfy a condition.

Considering the following documents:

```jsx
{ "id": 1, "product": "T-shirt", "price": 20 }
{ "id": 2, "product": "T-shirt" }
{ "id": 3, "product": "T-shirt", "price": 30 }

```

`NOT price = 20` should return all documents whose price attribute is not equal to 20.

With v0.29, the `!=` (`NOT`) filter matches documents missing the specified attributes. In the above example, this means Meilisearch returns documents `2` and `3`.

Before v0.29, Meilisearch did not include results missing the `price` attribute. In the above example, v0.28 would have returned only document `3`.

You can make sure a filter only returns documents containing the specified attribute by using the `!=` (`NOT`) operator with the new  `EXISTS` operator: `price EXISTS AND price != 20` will only return document `3`.

Improvement: key management
---------------------------

When managing [keys](https://docs.meilisearch.com/learn/security/master_api_keys.html#protecting-a-meilisearch-instance), using the `*` wildcard character in the `actions` array gives access to all endpoints:

```json
{
      "name": "Default Admin API Key",
      "description": "Use it for anything that is not a search operation. Caution! Do not expose it on a public frontend",
      "key": "380689dd379232519a54d15935750cc7625620a2ea2fc06907cb40ba5b421b6f",
      "uid": "20f7e4c4-612c-4dd1-b783-7934cc038213",
      "actions": ["*"],
      "indexes": ["*"],
      "expiresAt": null,
      "createdAt": "2021-08-11T10:00:00Z",
      "updatedAt": "2021-08-11T10:00:00Z"
 }

```

Now, thanks to our contributors, it can also be used as a wildcard to express all endpoints for a single particular route 🙌

Instead of having to list each and every single endpoint, you can append the `*` character to the desired route. For example, `documents.*` authorizes access to all document-related endpoints.

Improvement: Thai support
-------------------------

Our dear contributor [@aFluffyHotdog](https://github.com/aFluffyHotdog) has introduced [optimized support](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#what-do-you-mean-when-you-say-meilisearch-offers-optimized-support-for-a-language) for Thai 🥳

We are always looking for ways to make Meilisearch’s language support even better. The more [feedback](https://github.com/meilisearch/product/discussions?discussions_q=label%3Aproduct%3Acore%3Atokenizer) we get from native speakers, the easier it is for us to understand how to improve performance and search relevancy for those languages.

Want to help us [support your language](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#improving-our-language-support)? [Contribute](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md)! Don’t hesitate to [reach out](https://discord.gg/meilisearch) if you need guidance or help; we are looking forward to working with you!

Contributors
------------

Meilisearch could not exist as it does today without the support from our community. You're really, truly great and we can't thank you enough for all the effort, suggestions, comments, and time you dedicate to Meilisearch. This month, we want to send a special thank you to [@evpeople](https://github.com/evpeople), [@Mcdostone](https://github.com/Mcdostone), [@pavo-tusker](https://github.com/pavo-tusker), [@phdavis1027](https://github.com/phdavis1027), [@ryanrussell](https://github.com/ryanrussell), and [@VasiliySoldatkin](https://github.com/VasiliySoldatkin) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch), [@GraDKh](https://github.com/GraDKh) for his help with [Milli](https://github.com/meilisearch/milli), and [@aFluffyHotdog](https://github.com/aFluffyHotdog), [@matthias-wright](https://github.com/matthias-wright), and [@mosuka](https://github.com/mosuka) for their help with our tokenizer [Charabia](https://github.com/meilisearch/charabia).

And that's all, folks! Remember to check out the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.29.0) for the full release notes, and see you next time!

What’s new in v0.29

October is finally upon us, and with it comes Hacktoberfest, a staple in the open-source community. Once a year and for a whole month, we all come together and contribute to open-source projects.

But this won’t be the first time Meilisearch joins the melee! We've been participating since 2020, and each time you consistently blew us away with your passion and hard work. Looking back on everything accomplished last year, we're so proud that last year we merged 159 PRs from 90 different collaborators. We're very grateful for your input which allows Meilisearch to grow and progress so quickly.

<Callout>
  **And now, we're back for more, ready with 37** [**repos**](https://github.com/search?q=org%3Ameilisearch+topic%3Ahacktoberfest&type=Repositories) **and 185** [**issues**](https://github.com/search?q=org%3Ameilisearch+label%3Ahacktoberfest&state=open&type=Issues) **eligible for the event!**
</Callout>

### **A little bit about us**

Meilisearch is an open-source search engine built in Rust. Both team and community worked hard to build integrations with most of the popular development languages, frameworks, and deployment options so that Meilisearch fits seamlessly into most developer workflows. Our goal: a simple and intuitive experience for both developers and end-users.

Our main repository, [meilisearch](https://github.com/meilisearch/meilisearch), handles the power of our core engine [milli](https://github.com/meilisearch/milli/) and other libraries it’s built on. These include  [Charabia](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md), our tokenizer, which allows us to offer optimized  support for space-separated languages (like English and French), Hebrew, Chinese, Japanese and Thai.

 Does that sound interesting? Why not consider contributing to our project this year?

If you're keen on knowing which [Meilisearch repositories](https://github.com/search?q=org%3Ameilisearch+topic%3Ahacktoberfest&type=Repositories) are eligible for Hacktoberfest, then the answer is… a whole bunch of them! You'll be able to support our efforts by improving the [Ruby](https://github.com/meilisearch/meilisearch-ruby) SDK, the [Python](https://github.com/meilisearch/meilisearch-python) or the [Rust](https://github.com/meilisearch/meilisearch-rust) wrapper, and even polishing [Swift](https://github.com/meilisearch/meilisearch-swift) or [JavaScript](https://github.com/meilisearch/meilisearch-js) clients for the Meilisearch API. And that's to quote only a few of them. You can contribute to whichever repository you're most comfortable with or, on the contrary, decide to challenge yourself with something less familiar. Hacktoberfest is a great time to experiment and push your limits!

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

### **Hacktoberfest guidelines @ Meilisearch:**

First, if you're keen on participating, why not look at our official guidelines right [here](https://github.com/meilisearch/.github/blob/main/Hacktoberfest_2022_contributors_guidelines.md). Following these ensures we can provide you with the best contributing experience, including efficient reviews of your PRs. In short, this is what the guidelines are all about:

*   Our official reviewing window is Mon-Thur worktime (CEST)
*   After our maintainers take the time to review your work, please make sure to address all their comments before requesting more feedback
*   We will not accept contributions to our documentation repo this year
*   We do not assign issues to contributors: instead, the team will approve the PR that best solves the problem at hand
*   We will not consider low-quality PRs. If you're unsure what we mean by "low-quality PR", take a look at how the Hacktoberfest organizers define it in their [participation guidelines](https://hacktoberfest.com/participation/#spam) 

We've tagged repos with the Hacktoberfest topic. All contributions to these repositories are eligible for the event, but we added the Hacktoberfest label to the issues  we feel  are the best suited for contributions. We hope this will also allow you to navigate our repositories more easily.

### **What type of contribution for Hacktoberfest 2022?**

Hacktoberfest is a time to celebrate everything open-source. Code-oriented contributions are more than welcome as always, but that's not all! The open-source community _is_ vast and multi-talented.

While the documentation repository is not taking part this year, you can participate in our [Awesome Meilisearch](https://github.com/meilisearch/awesome-meilisearch) repos by [adding new resources](https://github.com/meilisearch/awesome-meilisearch/blob/main/CONTRIBUTING.md). These resources have to be links to awesome blog posts, tutorials, demos, guides, talks, or just about anything else that teaches people how to do cool things with Meilisearch. You can also create videos if that's where your talent lies. Any demos and talks, use cases, or posts will be equally appreciated. 

### **Extra rewards and shared goals**

Last year, as a small token of gratitude to our contributors, we sent exclusive Meilisearch swag all over the world in the form of a reusable bottle and a few fancy stickers. Unfortunately, we faced dispatching and customs issues in some countries and not everyone received their package. We've learned from our mistakes and came up with  solutions that will allow us to circumvent similar problems this year. So, rest assured: we have  prepared new exclusive swag and this time we’ll ensure everyone gets it. These goods are additional rewards you can receive on top of the ones provided by the Hacktoberfest organizers.

In a similar spirit, last year we set common goals that, if reached, would translate into a monetary donation toward three families of organizations that strive for diversity and inclusivity in software engineering. As you might have heard, we smashed these  collective goals, donating a total of 4500 euros to nine different organizations, all tacking important issues ranging from inclusivity in tech, open source maintainers and climate activists. Motivated by last year's success, we will renew our commitment to creating common goals for a set of different organizations.

It's still too early for us to spoil the surprise, but be on the lookout for our future blog post sharing all the details of our goodies boxes and common goals.

### **Join our community!**

We invite you to join our [community](https://discord.gg/meilisearch) and our dedicated #[hacktoberfest](https://meilicommunity.slack.com/archives/C02G1H43J2X) channel where both Meilisearch employees and fellow contributors mingle. Hacktoberfest isn't only a good time to work on a project, it's also a fantastic opportunity to meet people passionate about open-source.

Questions? Doubts? Comments? We'd love to hear any feedback you may have concerning your Hacktoberfest experience.

###

Meilisearch returns for Hacktoberfest 2022!

<Callout>
  This tutorial was originally published in November 2021, when the latest Meilisearch version was 0.24. It has now been updated to be **compatible with Meilisearch v1.0**.
</Callout>

Introduction
------------

In this tutorial, you'll learn how to integrate Meilisearch with your Rails application database and quickly create a front-end search bar with a search-as-you-type experience using React.

We will create a very basic application; our main focus will be the search. Therefore we won't go into much detail about Rails or React.

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

To follow this tutorial, you need:

*   [Node.js](https://nodejs.org/) >=16.10
*   [yarn](https://yarnpkg.com/) 1
*   [Ruby](https://www.ruby-lang.org) >= 2.7
*   [Ruby on Rails](https://guides.rubyonrails.org/getting_started.html#creating-a-new-rails-project-installing-rails) 7.0

Ideally, you are familiar with Ruby on Rails and have already created a simple RoR app. If that's not the case, you can still follow this tutorial, but as we stated in the introduction, explanations will focus on the search.

Step 1. Installing Meilisearch
------------------------------

There are [several ways](https://www.meilisearch.com/docs/learn/getting_started/installation#download-and-launch) to install Meilisearch. The easiest way to run a Meilisearch instance is using [Meilisearch Cloud](https://cloud.meilisearch.com/?ref=blog.meilisearch.com), there's a free 14-day trial, no credit card required. Meilisearch is open-source. In this tutorial, we'll run it locally with [cURL](https://curl.se/), a tool that allows you to make HTTP requests and transfer data from the command line.

Open your terminal and paste the following lines of code:

```bash
# Install Meilisearch
curl -L https://install.meilisearch.com | sh

# Launch Meilisearch
./meilisearch
```

Step 2. Creating and setting up your Rails app
----------------------------------------------

Now that you've got Meilisearch up and running, let's create our RoR app.‌‌ We will create a simple recipe app named `delicious_meals`. Run the following command on the terminal:

```bash
rails new delicious_meals -j esbuild
```

‌Let's generate our model `Recipe`. It will have four attributes:

1.  `title`
2.  `ingredients`
3.  `directions`
4.  `diet`

Go into the project folder and run the following command:

```bash
bin/rails g model Recipe title:string ingredients:text directions:text diet:string
```

This command also generates the migration file inside the `db/migrate` directory. Let's add the `null: false` option next to each column of the table so that no recipe is saved to the database if a field is empty.

```ruby
class CreateRecipes < ActiveRecord::Migration[7.0]
  def change
    create_table :recipes do |t|
      t.string :title, null: false
      t.text :ingredients, null: false
      t.text :directions, null: false
      t.string :diet, null: false

      t.timestamps
    end
  end
end

```

The `timestamps` column method adds two extra fields to the table: `created_at` and `updated_at`.

You can now create the database and run the migration above with the following commands:

```bash
# Creates the database 
bin/rails db:create 

# Runs the migration 
bin/rails db:migrate
```

Next, you need to generate the controller with its `index` action.

```bash
bin/rails g controller Recipes index
```

We will use the `index` view to show our recipes and search through them with our search bar. We won't generate the rest of the CRUD actions, as it would exceed the purpose of this tutorial.

Once the controller is created, modify the `config/routes.rb` file to look like this:

```ruby
Rails.application.routes.draw do
  # Maps requests to the root of the application to the index action of the 'Recipes controller'
  root "recipes#index"
end
```

Now, the `root` route is mapped to the `index` action of `RecipesController`. That way, the content of `app/views/recipes/index.html.erb` will be rendered at the root of your application.

You can check that everything is working as intended by starting the application with the following command:

```bash
bin/dev
```

Open your browser window and navigate to [`http://127.0.0.1:3000`](http://127.0.0.1:3000). You should see your index view displaying a message such as:

Recipes#index
=============

Find me in app/views/recipes/index.html.erb

Step 3. Adding Meilisearch to your app
--------------------------------------

Now that we have the back-end basics of our application, let's connect it to our running Meilisearch instance using the `meilisearch-rails` gem.

Install it by running the following command:

```ruby
bundle add meilisearch-rails
```
<Callout>
  When this tutorial was last updated, the latest version of the gem was 0.8.1. You can check the latest version in the [meilisearch-rails GitHub repository](https://github.com/meilisearch/meilisearch-rails) or on [Meilisearch finds rubygems](https://rubygems.meilisearch.com/?q=meilisearch-rails).
</Callout>

Create a file named `meilisearch.rb` inside the `config/initializers/` folder to setup your `MEILISEARCH_HOST` and `MEILISEARCH_API_KEY`:

```bash
touch config/initializers/meilisearch.rb
```

If you have followed [step 1](/blog/how-to-integrate-an-extremely-fast-and-relevant-search-into-your-rails-app-using-meilisearch-and-react/#step-1-installing-meilisearch) to the letter, your Meilisearch host should be [`http://localhost:7700`](http://localhost:7700). Since we did not set any API key, we will comment out the line with the `meilisearch_api_key` field:

```ruby
MeiliSearch::Rails.configuration = {
    meilisearch_url: 'http://localhost:7700',
    # meilisearch_api_key: ''
}
```
<Callout>
  You will need a master or a private key in production, you can learn more about it [here](https://www.meilisearch.com/docs/learn/security/master_api_keys#protecting-a-meilisearch-instance).
</Callout>

If you did set a master key, you have to update your configuration accordingly before running Meilisearch ([see step 1](/blog/how-to-integrate-an-extremely-fast-and-relevant-search-into-your-rails-app-using-meilisearch-and-react/#step-1-installing-meilisearch)et's open our `app/models/recipe.rb` file and add the following line inside the `Class` declaration:

```ruby
include MeiliSearch::Rails
```

We also need to add a `meilisearch block`. Note that the settings inside the Meilisearch block are not mandatory.

```ruby
class Recipe < ApplicationRecord
    include MeiliSearch::Rails
    
    meilisearch do
        # all attributes will be sent to Meilisearch if block is left empty
        displayed_attributes [:id, :title, :ingredients, :directions, :diet]
        searchable_attributes [:title, :ingredients, :directions, :diet]
        filterable_attributes [:diet]
    end
end

```

Let's break down each line of code:

### Setting displayed attributes

```ruby
displayed_attributes [:id, :title, :ingredients, :directions, :diet]
```

By default, Meilisearch displays all the attributes. Here, we are instructing Meilisearch to only display the specified attributes in the search response, this setting prevents Meilisearch from displaying the `created_at` and `updated_at` fields.

<Callout>
  You can learn more about `displayed attributes` in our [documentation](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#displayed-fields).
</Callout>

### Setting searchable attributes

```ruby
searchable_attributes [:title, :ingredients, :directions, :diet]
```

With the above line of code, we are doing two things:

1.  We first tell Meilisearch to only search among the specified attributes when performing a search query. So it won't try to find matches in the `id`, `created_at` and `updated_at` fields.
2.  We are also specifying the order of importance of the attributes. We are telling Meilisearch that a document with a matching query word found in its `title` is more relevant than a document with a matching query word found in `directions`. The first document is more relevant and is returned first in the search results.

<Callout>
  Learn more about `searchable fields` in our [documentation](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#searchable-fields).
</Callout>

### Setting filterable attributes

```ruby
filterable_attributes [:diet] 
```

Finally, we are telling Meilisearch that we want to be able to **refine our search results** based on the `diet` type. That will allow us to search only for vegetarian recipes, for instance.

<Callout>
  Visit our [documentation](https://www.meilisearch.com/docs/learn/advanced/filtering) to know more about filtering.
</Callout>

Step 4. Seeding the database
----------------------------

To test our application, we need some data in our database. The quickest way is to populate the database with dummy data using a gem called [_faker_](https://github.com/faker-ruby/faker)_._

Add the following line to your `Gemfile` inside the development group, save and run `bundle install`:

```ruby
gem 'faker', :git => 'https://github.com/faker-ruby/faker.git', :branch => 'master' 
```

Then open the `./db/seeds.rb` file and add the following code to populate your database with 1000 recipes:

```ruby
# Deletes existing recipes, useful if you seed several times
Recipe.destroy_all

# Creates 1000 fake recipes
1000.times do
    Recipe.create!(
        title: "#{Faker::Food.dish} by #{Faker::Name.unique.name}",
        ingredients: "#{Faker::Food.ingredient}, #{Faker::Food.ingredient}, #{Faker::Food.ingredient}",
        directions: Faker::Food.description,
        diet: ['omnivore', 'pescetarian', 'vegetarian', 'vegan'].sample
    )
end 

# Displays the following message in the console once the seeding is done
puts 'Recipes created'
```

Now, run `bin/rails db:seed` in the command line.

Step 5. Testing search with the search preview
----------------------------------------------

Meilisearch delivers an out-of-the-box web interface to test it interactively. Open your browser and go to the Meilisearch HTTP address, which should be [`http://localhost:7700`](http://localhost:7700), unless you specified it otherwise [at launch](https://www.meilisearch.com/docs/learn/configuration/instance_options#http-address-port-binding).

<Callout>
  Adding documents to an index is an asynchronous operation, don't worry if you don't see the 1000 documents right away. It might take some time for the updates to process. Learn more about asynchronous updates [here](https://www.meilisearch.com/docs/learn/advanced/asynchronous_operations).
</Callout>

Make sure the `Recipe` index is selected in the menu located at the top right, next to the search bar.

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

As you can see, the data has been automatically added to our Meilisearch instance. The only visible and searchable attributes are the ones [we specified in our model file](/blog/how-to-integrate-an-extremely-fast-and-relevant-search-into-your-rails-app-using-meilisearch-and-react/#setting-displayed-attributes)nside the `meilisearch block`. Please note that your search results may be different from those shown in the GIF, since _faker_ randomly generates data.

This is great for testing Meilisearch and some of its features, but it doesn't showcase the `filterable_attributes` we specified in our block. We need a custom UI for production.

Step 6. Adding React to the Rails app
-------------------------------------

There are several ways of using ReactJS with Rails. We have chosen the most straightforward one: installing it as a JavaScript dependency in our Rails application.

Run the following command to install **ReactJS** and its **react-dom** package for working with the DOM:

```bash
yarn add react react-dom
```

Let's create the folders and files for our React code.

```bash
mkdir app/javascript/recipes 
touch app/javascript/recipes/index.jsx 
touch app/javascript/recipes/App.jsx
```

Let's open `app/javascript/recipes/index.jsx` and add the required code to render our React elements:

```jsx
import React from 'react';
import { createRoot } from 'react-dom/client';
import App from './App';

const container = document.getElementById('app');
const root = createRoot(container); 
root.render(<App/>);

```

Open the `app/javascript/application.js` and import the file we just created:

```JavaScript
import "./recipes"
```

Step 7. Integrating a front-end search bar
------------------------------------------

To integrate a front-end search bar, you need to install two packages:

*   **[React InstantSearch](https://github.com/algolia/react-instantsearch)**: an open-source library that provides all the front-end tools you need to customize your search bar environment
*   **[Instant Meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch)**: the Meilisearch client to establish the communication between your Meilisearch instance and the React InstantSearch library

```bash
yarn add react-instantsearch-dom @meilisearch/instant-meilisearch
```

You can now open your `app/javascript/recipes/App.jsx` file and replace the existing code with the code from the `meilisearch-react` [Getting Started](https://github.com/meilisearch/meilisearch-react/#getting-started) guide. We only need to modify the `searchClient` with our Meilisearch host and Meilisearch API key, as well as the `indexName`. It should look like this:

```jsx
import React from "react"
import { InstantSearch, Highlight, SearchBox, Hits } from 'react-instantsearch-dom';
import { instantMeiliSearch } from '@meilisearch/instant-meilisearch';

const searchClient = instantMeiliSearch(
  "http://localhost:7700", // Your Meilisearch host
  "" // Your Meilisearch API key, if you have set one
);

const App = () => (
  <InstantSearch
    indexName="Recipe" // Change your index name here
    searchClient={searchClient}
  >
    <SearchBox />
    <Hits hitComponent={Hit} />
  </InstantSearch>
);

const Hit = ({ hit }) => <Highlight attribute="title" hit={hit} />

export default App
```

Now, go to your `views` folder and replace the content of the `app/views/recipes/index.html.erb` with the code below:

```html
<div id="app"></div>
```

Now you can run the `bin/dev` command, open your browser and navigate to [`http://127.0.0.1:3000`](http://127.0.0.1:3000) and see the result:‌

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

Well, the search works, but it's not very pretty. Luckily, InstantSearch provides a [CSS theme](https://www.algolia.com/doc/guides/building-search-ui/widgets/customize-an-existing-widget/react/#loading-the-theme) you can add by inserting the following link into the `<head>` element of your `app/views/layouts/application.html.erb`:

```html
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/instantsearch.css@7.4.5/themes/satellite-min.css" integrity="sha256-TehzF/2QvNKhGQrrNpoOb2Ck4iGZ1J/DI4pkd2oUsBc=" crossorigin="anonymous">
```

You can also customize the widgets or create your own if you want to. Check the [React InstantSearch documentation](https://www.algolia.com/doc/guides/building-search-ui/widgets/customize-an-existing-widget/react/) for more details.

Let's check the rendering:

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

Not bad, right? But once again we lack the possibility of filtering the results by type of diet.

Step 8. Adding faceted search
-----------------------------

It's as simple as importing the `RefinementList` widget in your `App.jsx` file:

```jsx
import { InstantSearch, Highlight, SearchBox, Hits, RefinementList } from 'react-instantsearch-dom';
```

and adding it inside our `InstantSearch` widget, specifying the attribute we want to filter by:

```jsx
<RefinementList attribute="diet" />
```

To make it more aesthetic and practical, let's create two `<div>` elements to divide our components. On the left, we'll find the filters, and the search bar and results on the right.

You can also add a "Type of diet" heading along with the `ClearRefinements` widget. It allows you to clear all the filters just by clicking on it, instead of having to uncheck them one by one.

The file should now look like this:

```jsx
import React from "react"
import { InstantSearch, Highlight, SearchBox, Hits, RefinementList, ClearRefinements } from 'react-instantsearch-dom';
import { instantMeiliSearch } from '@meilisearch/instant-meilisearch';

const searchClient = instantMeiliSearch(
  "http://localhost:7700",
  ""
);

const App = () => (
  <InstantSearch
    indexName="Recipe" // Change your index name here
    searchClient={searchClient}
  >
    <div className="left-panel">
      <ClearRefinements />
      <h2>Type of diet</h2>
      <RefinementList attribute="diet" />
    </div>
    <div className="right-panel">
      <SearchBox />
      <Hits hitComponent={Hit} />
    </div>

  </InstantSearch>
);

const Hit = ({ hit }) => <Highlight attribute="title" hit={hit} />

export default App


```

For this to work we need to add some CSS. Let's create a `app/assets/stylesheets/recipes.css` file and add the following lines of code:

```css
.right-panel {
    margin-left: 210px;
}
  
.left-panel {
    float: left;
    width: 200px;
}
```

And just to make it even prettier, let's add some padding and margin to the body and the search bar, and change the font:

```json
/* app/assets/stylesheets/recipes.css */

body { 
    font-family: sans-serif; 
    padding: 1em; 
}

.ais-SearchBox { 
    margin: 1em 0; 
}

.right-panel {
    margin-left: 210px;
}

.left-panel {
    float: left;
    width: 200px;
}
```

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

And tada! 🎉  You have a nice search bar with a search-as-you-type experience ready! 🥳

⚠️ Because we used fake data to seed our database, the recipes' `title`s, `ingredients`, `directions`, and `diet` type are not necessarily consistent.

### Conclusion

We have learned how to synchronize our Ruby on Rails database with Meilisearch and customize our search settings directly on our Rails app, allowing us to search through our data in milliseconds. To top it all off, we have also created a faceted search interface with a search-as-you-type experience using React.

We have achieved all this seamlessly, thanks to [Meilisearch Rails](https://github.com/meilisearch/meilisearch-rails) and [Instant Meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch). Meilisearch has integrations for almost every popular language or framework. Take a look at the complete list in the [Meilisearch integration guides](https://github.com/meilisearch/integration-guides/).

If you have any questions, please join us on [Discord](https://discord.gg/meilisearch); we are always happy to hear from you. For more information on Meilisearch, check out our [Github repository](https://github.com/meilisearch/meilisearch/) and [official documentation](https://www.meilisearch.com/docs/).

How to integrate an extremely fast and relevant search into your Rails app using Meilisearch and React

Did you know that the first iteration of Meilisearch was created during a hackathon organized by a [school called 42](https://42.fr/)? We like to think Meilisearch would have found a way to exist no matter what—we just love our fast search and our company culture too much—but 42 was the perfect framework for Meilisearch to bloom.

42 is a French computer science school where mutual help is the cornerstone of everything. What makes 42 special is that collaboration is at the heart of it all: there are no teachers so students need to team up to make their projects work! At Meilisearch, we do not believe good profiles exclusively come from traditional engineering schools. This is something at the core of 42: not only is it fiercely collaborative, the school is also tuition-free and open to anyone from the age of 18, which ensures a healthy mix of different backgrounds. Incidentally, we do not believe good profiles have to come from 42 either. As I didn't go to 42 myself, this blog post has largely been written with [Charlotte's help](https://www.linkedin.com/in/charlotte-vermandel-8b0924b5/). She lived the 42 adventure and provided me with her insights for this blog post.

42 was our founders' first experience of collaborative work and it has been a huge inspiration on our company culture. In this blog post, I will share what we really wanted to keep from 42, and how we adapted it to Meilisearch.

Learning how to learn
---------------------

If 42 doesn't have any teachers, you may wonder just how skills are taught. Sadly, students do not drink a magic potion that unlocks all the questions about life, the universe, and everything.

Rather, students are confronted with projects they're expected to complete. By asking other students who were there before them, searching for resources by themselves, and trial and error, they ultimately discover new techniques that allow them to make progress.

This very hands-on approach allows one to develop the ultimate skill: learning how to learn. Students continuously develop their own special toolbox to tackle new challenges and projects. After a while, they know how to acquire the competences they need.

Meilisearch took its first steps (aww 🥺) with this principle very close to our heart. We learned many things in the field—and we still do! In the Integrations team for example, Amélie, Bruno and Charlotte (the ABCs of tool integration) deal with 35 repositories written in 15 languages. Though a solid understanding of different languages and programming paradigms is essential, the most important skill for their job is assimilating new contexts and adapting quickly to different ones.

When we hire new people, we look for curious learners who have the ability to become experts in their fields. Then, to allow each person to thrive and pursue their own interests, we developed a Career Framework that guides and supports curiosity and growth. For example, as they gain experience, some people might want to become managers; others might want to deepen their expertise and further specialize in their original role. Whatever each one of us chooses, the Career Framework is there to help keep us curious and constantly learning new things!

Don't let me be misunderstood
-----------------------------

In 1831, the mathematician [Evariste Galois wrote about science education in a magazine](https://publimath.univ-irem.fr/numerisation/AAP/AAP82004/AAP82004.pdf) (link leads to a PDF document in French): "When will \[students\] be given time to ponder this mass of knowledge... why do examiners only ask candidates questions in a convoluted way? It seems that they are afraid of being understood by those they are questioning... Do we think that science is too easy?"

Obfuscation of knowledge to flatter egos is still very common 191 years later. We believe egotistical and self-important personalities are a recurring problem in companies that expect employees to compete with each other. Though the underlying goal might be to keep “the best” people and discard everyone else, this sort of elitism is pure gatekeeping—something we're convinced is always a disservice to product quality.

At Meilisearch, our goal is to be understood by as many people as possible. Our experience at 42 showed us people from all sorts of backgrounds could work in IT as long as they were given free access to the knowledge necessary to learn the trade.

This is why documentation has been a cornerstone of Meilisearch from the start. We want to make all developers feel they can understand and use Meilisearch, regardless of whether they're just starting out or have many years of experience.

Learning > Ego
--------------

However, pride is a very natural human emotion and it can be quite hard to let go of it. (I deliberately avoided writing "let it go" so you wouldn't have [a particular song in mind](https://www.youtube.com/watch?v=L0MK7qz13bU), but I'm afraid the effect is now busted. Sorry about this.) For instance, it can be hard to embrace constructive feedback, especially if it touches upon something we feel is very important.

Loving to learn new things has been very efficient in our experience. If you replace your own ego and pride with something more powerful, such as the incredible joy of learning something new, it starts to be easier to embrace feedback!

Learning new things from different sources makes our jobs way more enjoyable. We are constantly tickled by new concepts. Sometimes our coworkers feed us new thoughts, sometimes we stumble upon them serendipitously, and sometimes we just simply seek them out when trying to solve a difficult problem… Whatever the source and the final result, we love the journey.

Collectively responsible
------------------------

If you are feeling alone in your quest to shed your own ego, don't worry! It can very well be one of the most difficult things to achieve. We all want to feel we have good ideas and that our work is appreciated!

This is another aspect where 42's approach is helpful. The philosophy behind 42 is that peers are collectively responsible for the outcome of a project. This means that we're all in it together and acknowledges that all victories (and all losses) are a collective effort. Your colleague might have written a crucial bit of code, but they wouldn't have been able to without your support.

And what does that support look like? Glad you asked. A person may be the owner of the project they're working on, but their peers are the judges of whether it's all good and ready to launch. This means people have to be very rigorous in their reviews. The quality of your project is their responsibility too! We care about code quality, and in exchange we give all the attention in the world to your individual mission. Even individual projects at Meilisearch are collective because something that's  useful to one of us is useful to all of us—we are a team and if something allows you to work better, we all work better.

Our new hires adapt very quickly to this way of working. It's more comfortable and pleasant to be in a constructive dialogue with your colleagues than to compete with them all the time.

Constant feedback
-----------------

At 42, feedback goes hand-in-hand with a constant change of status: a person reviewing a project one day will be reviewed the next day. As the reviewers and the reviewees are always switching places, students naturally grow to both make thoughtful and constructive comments and  take feedback seriously, whatever the source. Our biases may falsely lead us to disregard criticism when they come from people we deem less experienced than we are. A collective accountability can lead to accepting a remark based on its own merits rather than the individual delivering it. Of course, this is not to say all criticism is relevant or that specialized experts are wrong and beginners are always right, only that we shouldn't be too quick to dismiss important feedback on a huff.

As a company, this way of thinking is very important to us. We want everyone working at Meilisearch to be able to voice their opinions and be heard. We cultivate patience and kindness in the feedback we give: it's a win-win situation because everyone will eventually give _and_ take feedback at different times—yes, even the founders and the managers!

This develops an inner sense of ownership. People feel collectively involved in the quality of the work we make. This is something we want to keep at Meilisearch's core because it has a huge impact on how we approach our own projects and the sense of joy and satisfaction we get from collaborating.

* * *

At 42, strong individual performers who can't work within a team will not pass the pool (4 weeks of intensive coding to select people who will join the school) if they haven't mixed well with others. This resonated with us: Meilisearch is a team and we think we are collectively stronger as such. Though it's very human to want to be a hero and save the world, it's not actually sustainable, efficient, or the way to produce the best possible code.

We are continuously building upon our experience with the 42 philosophy. We are now functioning within a more structured environment that gives us the necessary freedom to collaborate with a bigger team, in different time zones.

As an open-source company, our contributors and community are at the core of what we do. It makes sense to follow the same principle internally: being able to rely on our colleagues, and them on us in turn, means we can continue to learn and experiment in a safe environment, while being sure our work has been thoroughly tested and commented on. We can then truly say that Meilisearch is greater than the sum of its parts—and be very, very proud of it!

P.-S. Are you wondering if this article is the fruit of collaborative work? But of course! Many thanks to [Charlotte](/blog/author/charlotte/) [Quentin](/blog/author/quentin/) [Ferdinand](/blog/author/ferdinand/)nd [Morgane](/blog/author/morgane/)or reviewing this post, and especially to [Gui](/blog/author/gui/)ho penned many of the sentences you just read.

How Meilisearch built upon the computer science school 42's collaborative approach

In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. This release brings you new features such as smart crop and deterministic API keys. With v0.28, we have stabilized our API, taking the first step towards a v1.0 🎉 This stabilization brings multiple changes. You can read [the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.28.0), but we’ll go over the main ones in this article.

**New feature: smart crop**
---------------------------

Instead of considering the first search term match as the best cropping location, Meilisearch centers the crop around the largest number of unique matches, giving priority to terms that are closer to each other and follow the original query order.  Meilisearch also considers context when cropping and prioritizes keeping the sentence together.

Given the following string:

<Callout>
  “A young elephant, whose oversized ears enable him to fly, helps save a struggling circus, but when the circus plans a new venture, Dumbo and his friends discover dark secrets beneath its shiny veneer.”‌
</Callout>

If the search query is `Dumbo` and the `cropLength` is `5`, Meilisearch will now return:

`"… Dumbo and his friends discover…”`

Instead of:

`"…new venture, Dumbo and his…”`

**New feature: deterministic API keys**
---------------------------------------

A **deterministic algorithm** is an algorithm that, given a particular input, always produces the same output, with no randomness involved.

You can create a deterministic `key` value by specifying a `uid` field at creation. The `uid` value must follow the [uuid v4](https://www.sohamkamani.com/uuid-versions-explained) format. If you don't specify anything, Meilisearch automatically generates the `uid` for you.

The value of the `key` field is generated by hashing the master key with the `uid`. The same combination always results in the same `key` value.

This will allow you to have the same set of API keys across different Meilisearch instances. Henceforth, when upgrading or redeploying your Meilisearch instance, you’ll be able to keep your API keys.

<Callout>
  As a result of these modifications, keys imported from older versions of Meilisearch will have their `key` and `uid` fields regenerated. When updating your Meilisearch instance, **you will need to update your keys**.
</Callout>

We have also added a `name` field to make API key retrieval more convenient. A key object should now look like this:

```JSON
{
    "name": null,
    "description": "Manage documents: Products/Reviews API key",
    "key": "d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4",
    "uid": "6062abda-a5aa-4414-ac91-ecd7944c0f8d",
    "actions": [
        "documents.add",
        "documents.delete"
    ],
    "indexes": [
        "products",
        "reviews"
    ],
    "expiresAt": "2021-12-31T23:59:59Z",
    "createdAt": "2021-10-12T00:00:00Z",
    "updatedAt": "2021-10-13T15:00:00Z"
}
```

‌Other changes regarding API key management include:

*   being able to retrieve, update, and delete a key by either the `key` or `uid` fields
*   introducing new actions to manage API keys (`keys.get`, `keys.create`, `keys.update`, `keys.delete`)
*   removing the possibility of updating the `actions`, `indexes`, or `expiresAt` properties of an API key after creation for security reasons

**Breaking change: search nomenclature**
----------------------------------------

We’re on the road to v1, which means defining a stable API. To improve clarity, we have made several changes to the naming of some search parameters and response fields in the `/indexes/{uid}/search` endpoint.

Search parameters formerly known as `facetsDistribution` and `matches` are now called `facets` and `showMatchesPosition`, respectively.

The response fields returned when using those parameters are now `facetDistribution` instead of `facetsDistribution` –note the suppression of the _s–_ and `_matchesPosition` instead of `_matchesInfo`.

The response field `nbHits` has been renamed `estimatedTotalHits`. This value was recurrently used to calculate the number of search result pages, which we strongly advise against. To learn how to paginate with Meilisearch without using `nbHits`, check out this [fresh new guide](https://docs.meilisearch.com/learn/advanced/pagination.html).

For the following query:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "q": "Shazam",
    "facets: ["genres"],
    "showMatchesPosition": true
  }'
```

‌You’ll get the following response:

```JSON

{
  "hits": [
    {
      "id": "287947",
      "title": "Shazam!",
      "poster": "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
      "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
      "release_date": 1553299200,
      "genres": [
        "Action",
        "Comedy",
        "Fantasy"
      ],
      "_matchesPosition": {
        "title": [
          {
            "start": 0,
            "length": 6
          }
        ]
      }
    },
    ...
  ],
  "estimatedTotalHits": 3,
  "query": "Shazam",
  "limit": 20,
  "offset": 0,
  "processingTimeMs": 4,
  "facetDistribution": {
    "genres": {
      "Action": 3,
      "Animation": 2,
      "Comedy": 1,
      "Fantasy": 1
    }
  }
}
 
```

**Breaking change: task management**
------------------------------------

### **Browsing tasks**

We have added a new pagination system to the `/tasks` endpoint.

With this change, it’s much easier to browse through the tasks, as their number can quickly grow in instances with a large number of asynchronous operations.

For each call to this endpoint, the response will return the following fields:

*   `limit`: number of tasks returned (defaults to 20)
*   `from`: the `uid` of the first task returned
*   `next`: the `uid` of the next task

To view the next page of results, you would repeat the same query, replacing the value of `from` with the value of `next`. When the value of `next` is `null`, there are no more tasks to view.

This type of pagination system is called _keyset pagination_. As opposed to offset pagination used to browse indexes, documents, and keys, it has two main advantages: it prevents any inconsistencies and, since there is no need to scan and count records, it’s more efficient, which is a significant advantage when your task queue grows fast.

### **Filtering tasks**

We have also made [the task list filterable](https://docs.meilisearch.com/reference/api/tasks.html#filtering-tasks). You can now get tasks by `status`, `type`, or `indexUid`.

For example, the following command returns all tasks belonging to the index movies that succeeded:

```bash
curl -X GET 'http://localhost:7700/tasks?indexUid=movies&status=succeeded'
```

‌These modifications have led to the deletion of the `GET /indexes/:indexUid/tasks`  and the `GET /indexes/:indexUid/tasks/:taskUid` endpoints.

**Breaking change: dumps**
--------------------------

Dump creation has always been an asynchronous operation but used a separate queue from the task queue. With v0.28, dumps have become tasks. This has resulted in a new task type called `dumpCreation`.

Despite being tasks and thus sharing the same queue, **dumps are given priority**. They’ll be processed as soon as the current task is done running. You can think of dumps as VIPs in a club; even though they arrived last - which is reflected in their `taskUid` - they get to skip the line.

[via GIPHY](https://giphy.com/gifs/fail-fun-entertainment-hKYigb3Djp8pa)

**Contributors’ experience**
----------------------------

We have worked hard on improving the contribution experience of our tokenizer: [charabia](https://github.com/meilisearch/charabia/). The tokenizer’s role is to split a sentence or phrase into smaller units of language, called tokens. It is a critical factor in the quality of search results. Now, it is much easier to add languages to Meilisearch. You just need to follow the instructions on [CONTRIBUTING.md](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md).

Meilisearch works perfectly with any space-separated language and has special support for Japanese and Chinese. **We now support Hebrew,** too, thanks to our awesome community! Other languages will still work, but the quality and relevancy of search results may vary significantly.

We would love to provide global language support. The more feedback we get from native speakers, the easier it is for us to understand how to improve performance for those languages. If you want to help us [support your language](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#improving-our-language-support), we are eager to hear from you and see how we could make progress together!

**Other changes**
-----------------

*   We have added pagination to the response of the `GET /indexes` and the `GET /keys` endpoints, and we have improved pagination for the `GET /indexes/{uid}/documents`
*   For performance reasons, we have decided to limit the number of facet values returned per faceted attribute. This limit is customizable and defaults to 100
*   You can customize the number of documents Meilisearch returns on search. The default limit is 1000 and protects the database from malicious scraping. Beware that increasing this limit can affect performance

We apologize in advance for any inconvenience caused by all these changes. It’s for a good cause: we are making these changes now to move towards v1.0 and avoid breaking changes later. Don’t hesitate to reach out to us if you need support or have any doubts. We are always happy to help!

**Contributors**
----------------

We are really grateful for this amazing community. We want to thank [@0x0x1](https://github.com/0x0x1), [@choznerol](https://github.com/choznerol), [@pierre-l](https://github.com/pierre-l), [@ryanrussell](https://github.com/ryanrussell), [@Thearas](https://github.com/Thearas), and [@walterbm](https://github.com/walterbm) for their help with Meilisearch, and [@matthias-wright](https://github.com/matthias-wright) for his help with [milli](https://github.com/meilisearch/milli). We want to send a special shout-out to [@benny-n](https://github.com/benny-n) for adding Hebrew to our [tokenizer](https://github.com/meilisearch/charabia).

And that’s it for v0.28! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.28.0) for the full release notes, and see you next time!

‌‌

What's new in v0.28

**Introduction**
----------------

If there's one feature Firebase is missing, it’s a good and efficient way for searching through data. Their [documentation](https://firebase.google.com/docs/firestore/solutions/search) suggests using a third-party solution:

> "Cloud Firestore doesn't support native indexing or search for text fields in documents. \[…\] To enable full-text search of your Cloud Firestore data, use a dedicated third-party search service."

[Firestore-meilisearch](https://github.com/meilisearch/firestore-meilisearch), Meilisearch’s official Firebase extension, synchronizes documents between a Cloud Firestore collection and a Meilisearch index, monitoring each time you create, update, or remove documents from that index. This ensures the data in Meilisearch mirrors your content in Cloud Firestore, effectively enabling you to create a fully-featured search experience.

In this tutorial, we'll show you how to install the `firestore-meilisearch` extension on your Firebase instance and add full-text search to your Cloud Firestore.

Tools
-----

*   **Firebase:** Firebase is a platform developed by Google to help developers create mobile and web applications. It is a fully managed back-end service that provides an infrastructure for web applications that handles everything from user authentication and server scaling to crash analytics and reliable testing environments.
*   **Meilisearch:** Meilisearch is a fast, open-source search engine that's a joy to use and deploy. Meilisearch allows you to create a relevant search experience out of the box in very few steps and with no configuration needed.

**Requirements**
----------------

**To run this project, you will need:**

*   A Google account with a billing profile set up
*   An open [terminal or command prompt](https://www.ionos.com/help/email/troubleshooting-mail-basicmail-business/access-the-command-prompt-or-terminal)
*   [Node.js](https://nodejs.org/en/download/) {">= 14 && <= 17"}
*   [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) >= v7

**Steps**
---------

Here's a summary of what we're going to do to create a nice search interface with Firebase and Meilisearch:

1.  Deploy Meilisearch
2.  Create a Firebase project
3.  Install Meilisearch’s Firebase extension
4.  Set up a search interface

**Deploy Meilisearch**
----------------------

For this tutorial, you will need a Meilisearch instance running on a cloud service. There are many ways [to deploy a Meilisearch instance](https://docs.meilisearch.com/learn/getting_started/quick_start.html#cloud-deploy). The easiest way to spawn a Meilisearch instance is using [Meilisearch Cloud](https://cloud.meilisearch.com/login), there's a free 14-day trial, no credit card required.

**Create Firebase project**
---------------------------

**Note:** you can skip this step if you already have a Firebase Project with a Firestore Database containing your documents.

Once we have our Meilisearch instance up and running, we can create a Firebase project, configure it, and add a Firestore database.

### Create **a project**

Follow the [Firebase documentation](https://firebase.google.com/docs/web/setup#create-project) to start your own project.

You should now have a project on your Firebase account that looks a bit like this:

![A look at a fresh new Firebase account settings](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_15_24_56_1_491fb374a2.png)

Once we have created a Firebase account and our project, we will need to add a Firestore Database to our project. Consult [Firebase’s documentation](https://firebase.google.com/docs/firestore/quickstart) for more instructions.

**Install Meilisearch extension**
---------------------------------

We now are ready to install the Meilisearch extension on our project.

### ⚠️  **Billing**

To install an extension, [your Firebase project must be on a special billing plan](https://github.com/meilisearch/firestore-meilisearch#billing) that will charge you at least 1 cent a month.

### Install and authorize `firestore-meilisearch`

To install the [`firestore-meilisearch`](https://github.com/meilisearch/firestore-meilisearch) extension on your Firebase project just follow this [link that will redirect you to your Firebase console](https://console.firebase.google.com/project/_/extensions/install?ref=meilisearch%2Ffirestore-meilisearch@0.1.3).

Select the project in which you want to install the extension. You will then have access to the installation panel. The panel consists of three main steps, with a final extension configuration section at the end:

1.  **Early Access Partner extension:** find `firestore-meilisearch` under Extensions Publisher Early Access Program, select it, and click on “Next”
2.  **Review billing and usage:** Firebase will inform you about the charges incurred by using extensions, which we recommend you read carefully. If Firebase offers the option, click on “Update project to continue;” otherwise, click on “Next”
3.  **Review APIs enabled and resources created:** Firebase will also give you more information about [Cloud Functions](https://firebase.google.com/docs/functions), a set of Firebase functionality we use in this extension. These instructions explain how Cloud Functions are triggered and their key capabilities

### **Configure `firestore-meilisearch`**

The fourth and final step for activating `firestore-meilisearch` is configuring it.

![Configuring the Meilisearch extension in Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_13_57_34_8e12fb4018.png)

1.  **Cloud Functions location:** select the region where the backend code will be called whenever a document is added, updated, or deleted from Firestore. We recommend selecting regions close to your users and your Meilisearch instance
2.  **Collection path:** the name of the Firestore collection you want to mirror in a Meilisearch index
3.  **Fields to index in Meilisearch (Optional):** optional setting gives you the possibility to only index some of the fields in the documents contained in your Firestore database
4.  **Meilisearch Index Name:** the name of the Meilisearch index containing your Firestore data. Meilisearch will automatically created this index if it doesn’t exist
5.  **Meilisearch host:** the URL of your Meilisearch instance
6.  **Meilisearch API key (Optional):** a Meilisearch API key with permission to perform actions on indexes. For more info on API keys, consult our [security guide](https://docs.meilisearch.com/learn/security/master_api_keys.html).

You can also install this extension via the command line. To do so, make sure you've got the [Firebase Command-Line tools installed](https://firebase.google.com/docs/cli), then run the following command:

```bash
firebase ext:install meilisearch/firestore-meilisearch --project=(your project ID)

```

### Check if everything is working!

Suppose we are creating an application that allows users to search through a database of movies. Our first step is to create a collection named `movies` in Firestore:

![Starting a collection on Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_21_at_18_49_25_c4de0afa47.png)

We can use Firestore Database’s access panel to manually add a movie document:

![Adding a document to Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_21_at_12_50_35_1_d5f5577498.png)

This is the data we are using in our example:

```raw
title
    The Hobbit: An Unexpected Journey

poster
    <https://image.tmdb.org/t/p/w500/yHA9Fc37VmpUA5UncTxxo3rTGVA.jpg>

overview
    Bilbo Baggins, a hobbit enjoying his quiet life, is swept into an epic quest by Gandalf the Grey and thirteen dwarves who seek to reclaim their mountain home from Smaug, the dragon.

release_date
    1353888000
```

Once you added this movie, you should be able to see it when accessing your instance’s [search preview](https://www.meilisearch.com/docs/learn/what_is_meilisearch/search_preview):

![Search preview of Meilisearch with a first document](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_21_at_12_51_45_2_7a422f3d42.png)

**Well done! You have successfully installed the Meilisearch Firestore extension!**

From now on, whenever you add, update, and delete documents from your Firestore collection they will be mirrored in the same way in your Meilisearch instance.

<Callout>
  This extension does not export all existing documents in Meilisearch unless they have been modified or created after its installation. You can run the import script provided by this extension to retrieve your dataset in Meilisearch with all documents present in your Firestore collection. For more information, check the [dedicated guide](https://github.com/meilisearch/firestore-meilisearch/blob/main/guides/IMPORT_EXISTING_DOCUMENTS.md) in our `firestore-meilisearch` repository.
</Callout>

### Managing your extension

To access the overview panel of the extension, first click on the “Extensions” tab on Firebase’s sidebar menu, then find the Meilisearch extension and click on “Manage.”

![Finding the Extensions tab in Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_42_52_58b56d1e77.png)

![Finding the Manage settings of meilisearch extension](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_29_51_1_c0cfafa489.png)

You will be directed to a page where you can access all the information about your extension, change its configuration, or even delete it.

![Configuring the Meilisearch extension for Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_30_06_e35e907ca8.png)

Accessing your logs allows you to monitor your cloud functions and obtain different levels of information. You may access an extension’s logs via the “Extensions” tab. Alternatively, you can also visit the “Functions” tab, then select “Logs,” as indicated in the image below.

![Finding the Functions tab in Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_34_39_3eee0c3654.png)

![Finding the Logs tab in the Function menu of Firebase](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_34_23_a40c6dba99.png)

![Looking at the logs to monitor Cloud Functions](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_33_57_561839c8a6.png)

![Isolating an interesting log of our Firebase extension](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_05_at_16_13_16_358ff97a54.png)

Set up a search interface
-------------------------

We are done with installing and configuring the `firestore-meilisearch` extension, but it's no fun if we don't get to try the search in an actual front-end application. In this optional part, we will see how to create a search bar for your project using [instant-meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch).

### **Populating your Firestore collection with data**

The first thing we need to do is add more documents to our Firestore database. In our case, we are going to use this [collection of movies](https://www.meilisearch.com/movies.json). Consult Firebase documentation for more information on [how to add and manage data](https://firebase.google.com/docs/firestore/manage-data/add-data).

Once you are finished adding content to your Firestore database, visit your instance’s [search preview](https://www.meilisearch.com/docs/learn/what_is_meilisearch/search_preview) to check your documents have been successfully indexed by Meilisearch.

![Search preview of the Firestore database](https://unable-actionable-car.media.strapiapp.com/Screenshot_2022_04_04_at_18_10_11_4e741a00b9.png)

### **Search in your document**

Now let's create a great search experience! There are many ways to do this, but we’ll keep it simple this time and use `instant-meilisearch`, our plugin for the `instant-search` JavaScript library. Read our article on [instant-meilisearch](/blog/instant-meilisearch/)o learn more.

Create an`index.html`file in your preferred development environment. This HTML page should contain a search bar and a box to contain the returned search results:

```bash
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Meilisearch demo</title>
    <link rel="stylesheet" href="<https://cdn.jsdelivr.net/npm/instantsearch.css/themes/algolia-min.css>" />
</head>
<body>
    <div>
        <div id="searchbox"></div>
        <div id="hits"></div>
      </div>
  
      <script src="<https://cdn.jsdelivr.net/npm/@meilisearch/instant-meilisearch/dist/instant-meilisearch.umd.min.js>"></script>
      <script src="<https://cdn.jsdelivr.net/npm/instantsearch.js@4>"></script>
      <script>
          const searchClient = instantMeiliSearch(
              'your Meilisearch url',
              'your Meilisearch API key'
            )
            const search = instantsearch({
              indexName: 'movies',
              searchClient
            })

            search.addWidgets([
              instantsearch.widgets.searchBox({
                container: '#searchbox',
              }),
              instantsearch.widgets.hits({
                container: '#hits',
                templates: {
                  item: `
                    <div style="text-align:center;">
                      <div class="hit-name">
                        {{#helpers.highlight}}{ "attribute": "title" }{{/helpers.highlight}}
                      </div>
                      </br>
                      <div>
                        <img src="{{poster}}" width="200px" />
                      </div>
                    </div>
                  `,
                },
              }),
            ])

            search.start()
      </script>
</body>
</html>

```

Don’t forget to replace the example’s configuration with your own data. This might include the `indexName`, if you named your index something other than `movies`, your instance’s URL, and your API key.

If everything went well, you should be able to access your `index.html` file and start searching right away:

![Showing how the search functionality works](https://unable-actionable-car.media.strapiapp.com/Apr_05_2022_12_55_55_66890e7900.gif)

**Congrats!** You have added full-text search capability to your Cloud Firestore. Your Firebase collection and your Meilisearch index will automatically stay in sync as long as the `firestore-meilisearch` extension is installed.

Thanks for following this little tutorial! Questions, comments, suggestions? Don't hesitate to [get in touch with us on GitHub](https://github.com/meilisearch/firestore-meilisearch)—trust us, we love your feedback.

Meilisearch latest news and company updates