Background and Gatsby

Our docs are built using Gatsby — a popular and open-source React framework for building websites and apps. However in the last couple of years, Docusaurus has emerged as a popular and focused alternative for an all batteries included approach to building a documentation site.

Given that we were already using Gatsby with hundreds of routed pages and using many features such as a custom navigation layout with picker for frontend libraries, a 0ms latency search box based on an offline index, our preference was to stay with Gatsby instead of migrating to a new tool like Docusaurus.

Besides, Gatsby being a framework and not being opionated would allow us to have more flexibility to make future enhancements, such as make use of server-side rendering.

It turns out that tuning performance as well as making several of the enhancements is indeed easy with Gatsby! The rest of the post walks through the enhancements. If you would like to incorporate any of these for your own documentation, our docs are built in the open on Github and licensed under MIT. Feel free to star or fork them.

Introducing dark mode

The docs now fully support viewing in dark mode.

Our docs primarily utilize the appbase.io design kit for several components like the TimelineOption component above. Cards, navbar, footer are all components that come from this. We introduced a dark theme option in these components first. The docs are built using Gatsby, the next changes to support theming were done in the core repository itself.

On mobile screens, we show the theme switcher with the menu navigation’s footer.

The default theme is also auto-set based on a user’s OS display preferences.

Searchbox enhancements

We’ve improved the documentation search experience with a wider screen space, a first-class keyboard accessibility support, showing and a quick suggestion view of recently viewed pages.

Code highlighting and copy snippet options

All the code snippets in the docs now support syntax highlighting using prismjs as well as support a copy snippet button.

Performance enhancements

appbase.io docs are a fully progressive web app that can be installed as an app when viewing from mobile and are also heavily SEO optimized.

We also focused on other performance enhancements such as using Loadable components, upgrading to Gatsby v4 (current major version) as well as utilizing several Gatsby plugins to reduce the Javascript needed for the docs to be interactive.

Open Source | Star it or fork it

If you are interested in incorporating any of these changes to your own documentation site, our docs are hosted in the open on Github and licensed under an MIT license. Go star it or fork it.

Improving the developer experience for appbase.io docs was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

Updates from this month:

We’ve been focusing on creating updated examples and blog posts that utilize the ReactiveSearch UI kit. Here are three updates for React and Vue developers looking to build search apps:

React dashboard search template

https://blog.reactivesearch.io/react-dashboard-template-with-elasticsearch

(7 mins read)

Are you looking for a ready-to-use and performant boilerplate for your next SaaS dashboard or BI dashboard project? Perhaps with advanced search capabilities! 🤩

What differentiates this template from other UI templates is that it works out of the box with both Elasticsearch and OpenSearch engines (you can scale to GBs of data and still get sub-second responses) and its use of ReactiveSearch — allowing you to swap any of the components in the template with others.

Want it to work only for logged-in users? We’ve got you covered ✅

Want to display aggregations data using rich charts? Look no further ✅

Buy the template from Gumroad for $99 — support included

Build a search UI with Vue and Elasticsearch

https://blog.reactivesearch.io/appsearch-with-vuejs-and-elasticsearch

(9 mins read)

This is a follow-along post (takes a couple of hours to build this end-to-end) showing how to build a consumer grade search UI using Vue and Elasticsearch. It makes use of the Vue variant of the https://github.com/appbaseio/reactivesearch library (Apache 2.0 licensed) that’s being used by over 100 projects for building their search UI.

The example here is of building a book search UI using Vue.JS and Elasticsearch, but the general principles covered should apply to other kinds of UIs as well.

Did you know ReactiveSearch is the only UI kit for Vue.JS that offers search UI components that work out of the box with both Elasticsearch and OpenSearch search engines?

We’ve been actively maintaining this UI kit since 2019, and it’s seeing serious production usage. Head over to the docs at: https://docs.appbase.io/docs/reactivesearch/vue/overview/QuickStart/ to see how to implement server-side rendering, bring your own UI components or even design systems.

Build a search UI with React and Elasticsearch

https://blog.reactivesearch.io/react-search-ui-tutorial

(14 mins read)

This is a follow-along post (takes a couple of hours to build this end-to-end) showing how to build a consumer grade search UI using React and Elasticsearch. It makes use of the https://github.com/appbaseio/reactivesearch library (Apache 2.0 licensed) that’s being used by over 1,200 projects for building their search UI.

The example used here is of a Netflix like movie search UI, but the general principles apply if you’re looking to build an e-commerce or aggregator like search UI.

There are tons of things you can do with ReactiveSearch that aren’t covered in this post, like optimize for SEO with server-side rendering, implementing authenticated search (Basic Auth, JWT), build geo search (we support OpenStreetMaps and GoogleMaps) UIs to name a few. You can start with the docs link from here: https://docs.appbase.io/docs/reactivesearch/v3/overview/quickstart/.

We will be publishing advanced tutorials next showing how to build Emoji search using natural language understanding, building knowledge graph search applications, building search with OpenAI and more. You can subscribe to this publication to get these right into your inbox!

March ‘22: ReactiveSearch Digest was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

At appbase.io, we’ve published over 10 different search UI libraries over the past few years. Depending on your search use-case: site search, e-commerce or geo search, performance requirements like SEO and server-side rendering, bundle size or the design flexibility needed to apply styles and integrating a design system, one may be a better fit than another. And it can be hard to tell which one to choose from all the available options out there.

So here’s a short quiz 🪄 that you can take to find the search UI library that best fits your use-case, performance and design requirements. You can also share your detailed use-case to get a personalized recommendation from our team. :-)

Or you can head to our docs to dig into all the available UI libraries as well as the no-code UI builder. 👀

Find the ✅ UI Library for your next Search 🔎 Project was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

Appbase.io’s no-code search UI builder now ships with an inline code editor that enables creating true consumer grade site search, e-commerce search, recommendations and 🆕 🗺 geo search experiences.

How does UI Builder enable building consumer grade searches:

For starters, appbase.io provides an app search platform for Elasticsearch and Opensearch clusters. You can connect your existing Elasticsearch cluster or host it with appbase.io.

• Login to your appbase.io dashboard and go to the UI Builder tab and choose the search index to build the search UI against.
• Next, pick a search layout theme, configure search relevance, configure the UI components (aka widgets) and results display format. All of this is configurable with no-code and takes only minutes. 🙌
• The configurator generates a React app (built with ReactiveSearch ⭐️) that you can now export or edit it inline using codesandbox.io editor. The ability to edit the resulting code and persist the resulting changes is what makes it possible to build and ship production search experiences!

This experience is years ahead of what other search interface builders offer. But don’t take our word for it! You can sign up for a free 14-days trial with appbase.io and try it yourself.

Configuring Geo Search Experiences

We will use an Airbnb search index to demonstrate a geo search experience built with appbase.io’s search UI builder and OpenStreetMaps.

To start with, pick the Geo theme.

Next, we will configure the filters (aka facets) to show for Bedrooms and Bed Type.

Finally, we will set the results fields to display and the map component to use: Here, we are using OpenStreetMaps but you can also easily pick GoogleMaps instead (note: This will require specifying the Google Maps API key)

And voila! 🪄 We have the geo search UI ready to be customized with code 🧑‍💻👩‍💻

Another Enhancement: Review and Save

UI Builder now stages the changes as you make them and provides a live preview view, but they’re only persisted / deployed live once you review and save them. This strikes the right balance between deploying changes instantly while having a peace of mind! 😌

Beyond enabling you to ship search experiences in hours instead of weeks, the search experiences can also record search analytics, provide performance insights into search relevance and content tweaks and make it a breeze to deploy changes continuously. 🔁

UI Builder is available with Production and Enterprise plans, as well as an addon to Sandbox and Starter plans. Sign up for a free 14-days trial over here.

Build Geo And Site Search Apps with No-code / Low-code was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

ReactiveSearch scripts is the outcome of when a JavaScript developer walks into an Elasticsearch bar 🍺

On a more serious note: When building a production grade search experience, one of the key challenges one runs into is defining a search relevancy strategy that works at scale. Lucene based search engines like ElasticSearch get you pretty far with a good out of the box algorithm along with tuning options. But when working at scale, there are hundreds of edge-cases, cascading side effects, long tail searches, synonyms to consider that you need to rely on an external system. At appbase.io, we have built Query Rules to meet this challenge — a set of “If this, then that” style rules that are configurable to meet a business’s unique search relevance needs.

However, at scale — using rules can be cumbersome and hard to maintain. To meet this need, we’re announcing a beta release of ReactiveSearch Scripts, a feature we’ve been hacking 🛠 on for the past several months. Scripts are user defined JavaScript functions that are executed in a latency optimized manner (powered by Google’s V8 engine). These are typically used during the request or response cycle of a search query, but can also be invoked with additional trigger conditions, or at a periodic schedule as a cron job.

Scripts are currently available as an action with appbase.io query rules (more ways to utilize scripts coming 🔜)

Why and When To Use ReactiveSearch Scripts

Scripts are architecturally similar to Cloudflare Workers (in that they utilize the V8 engine for execution) and serve similar use-cases to popular FaaS services such as AWS Lambda, Azure Cloud Functions, et al. Hence, an important question to address is when ReactiveSearch scripts are useful and when other options might be better.

If you’re powering search experiences where milliseconds matter, you should be using scripts. Besides utilizing the V8 engine and not suffering the cold start problem (since we don’t use containers), scripts are also run on the same server environment where the search engine and the appbase.io service is run. Scripts typically run in under 5ms [1] (~10x-20x faster than other services) and can perform IO operations against the search engine faster than an external service running in a different region or edge can.

[1] A request / response transformation script is this quick 🚀. Additional behaviors (e.g. performing NLP or using crypto utils may incur some more latencies). We will be benchmarking this more thoroughly in a future post.

ReactiveSearch Scripts are purposefully designed to serve search use-cases. They come with global packages like fetch, compromise (nlp), crypto.js, lodash to help with common request and response manipulations.

When using another FaaS service is better

If you’re performing an operation e.g. clustering, creating dense vectors, indexing data that’s not user facing or time-sensitive, ReactiveSearch scripts don’t offer an edge to using other FaaS services.

Use-cases for ReactiveSearch Scripts

Modify a request before querying Elasticsearch

• Use script to pre-process the user search query using NLP techniques
• Add dynamic fields to an Elasticsearch indexing request, for e.g. calculate age field from date of birth and add it to the document being indexed

Transform the search response

• Promote or hide search results based on a dynamic criterion
• Use an external API call to return additional context with the search response (e.g. implement a did you mean functionality)

Create side effects

• Implement a saved search functionality by posting search query to a 3rd party API (asynchronously)
• Log indexing requests or search queries that match a set criterion
• Send e-mail alerts based on a certain set of search queries

Run periodically

A script can also be run in a cron mode, where it is invoked at specific intervals.

• Regularly update the search index with data from a primary data source (e.g. Sync updated data from Postgres or MongoDB),
• Enrich data in the search index, e.g. perform named entity recognition,
• Perform classification of data, e.g. unsupervised clustering

Because scripts can call external APIs in both sync and async modes, there are no limits to what is possible.

Show me the code 🧑‍💻

The code snippet below uses the appbase.io dashboard’s editor functionality to validate a script. It uses compromise.js (a built-in module available in ReactiveSearch scripts) to interpret a user query such as: “smart phones under 10K” to extract the price information and then set a filter for the price before querying Elasticsearch.

The validate script dashboard feature uses the Monaco editor (the code editor that powers VSCode IDE) and lets you:

• Interactively write a script and catch any compile time errors
• Catch any runtime errors by simulating an entire request / response cycle
• Get a real response by hitting the search engine
• View any user set console logs
• Set environment variables that are available during the runtime.

The _script/validate endpoint can also be used as an API outside of the dashboard, so here’s a Repl that you can try out live:

Script - Request modification with compromise

Scripts are available today as part of Query Rules as a script action — a set of configurable rules to extend the search engine’s default relevance strategy.

Read more about scripts in the docs, and play with code examples on using additional authorization schemes with crypto.js, using sync and async fetch calls to interact with external APIs, modify an indexing or bulk request, using cron script to add a document into the search index periodically.

Coming Soon ➡️

If you’re excited about the potential of ⚡️ fast JavaScript functions, stay tuned for more posts! We’re working on improving the scripts Dx and making them more powerful 🦾

🆕 ReactiveSearch Scripts: JavaScript functions for when milliseconds matter 🚀 was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

Autocomplete.js is an open source, production-ready and widely popular JavaScript library for building autocomplete experiences from Algolia.

In this post, we will use an autocomplete.js plugin created by appbase.io (also open-source) to create rich typeahead experiences powered by Elasticsearch or OpenSearch.

First, let’s see a live demo of autocomplete.js powering a typeahead experience using a sample best buy search dataset:

How It Works

Autocomplete.js offers a sources API that allows fetching data from any source. The autocomplete-suggestions-plugin from appbase.io uses this feature to query the appbase.io suggestions API. The stack looks something like this:

As a developer, you would use the autocomplete.js suggestions plugin from appbase.io to create typeahead experiences.

Why use appbase.io suggestions API (or search API)?

While building an autocomplete experience based on the search index can be done with Elasticsearch itself, the appbase.io suggestions API exposes a declarative API for combining:

• Popular suggestions (searches other end users made that resulted in a positive outcome),
• Recent suggestions (your own history of searches) as well as,
• Query rules (think promoted / sponsored suggestions)

along with searching the index in a streamlined manner. In addition to these additional querying capabilities, it also allows returning suggestions by a category field, setting a URL field when hyperlinking externally is useful, and displaying predictive suggestions (similar to how Google’s typeahead works) instead of returning the entire field’s match value.

Any combination of all of the above can be configured declaratively within a single API call — allowing you to build autocomplete experiences tailored to your specific use-case.

In less than 60 lines of code, we have an autocomplete typeahead experience with our preferred config for the suggestions API all setup 🙌

Examples

Here are different examples of using typeahead use-cases:

• The above basic example with an added results component

• An advanced example that uses two instances of the autocomplete suggestions plugin

• An example showing category suggestions

• An example using Autocomplete.js with React

• An example using Autocomplete.js with Vue

• An example showing how to add custom analytics events with the search query

Summary

We just how to use Autocomplete.js plugin with an Elasticsearch or OpenSearch cluster using the autocomplete-suggestions-plugin.

It only takes about 60 lines of code to get a fully functional autocomplete experience tailored to your use-case up and running (including what kinds of suggestions to fetch and how to render them).

Finally, we saw different examples of using autocomplete.js — from using it with Vanilla JavaScript, React, or Vue to using multiple instances of the plugin to render different kinds of suggestions to sending custom analytics events.

You can read the getting started docs for using autocomplete.js with Elasticsearch over here:

Appbase.io Docs - Search stack for Elasticsearch

If you would like to dig deeper, check out the API reference over here:

Appbase.io Docs - Search stack for Elasticsearch

Or read various guides on integrating with React, Vue, adding popular suggestions, adding recent suggestions, displaying multiple types of results, sending custom analytics events, adding a custom renderer, reshaping sources, and more:

Appbase.io Docs - Search stack for Elasticsearch

Build Typeahead Experiences With Algolia Autocomplete.js And Elasticsearch was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Search engines have become essential components for almost every user-facing application. For retailers, search results and recommendations directly drive revenue — since they enable users to find products fast, discover new products they hadn’t previously considered, all while offering businesses opportunities to better understand each customer and deepen engagement.

Being able to tailor experiences unique to a user’s search preferences, in order to surface more relevant content to them, is especially important for social media, digital media and e-commerce apps. For example, if I search for houseplant care videos on TikTok, I’ll be more likely to receive those types of recommendations moving forward.

Key Problems with Building App Search Today

The majority of search experiences built today are powered by bolt-on search solutions like Elasticsearch, Solr, or Algolia.

Because of the bolt-on nature of search solutions that are prevalent today, the total cost comes down to much more than the sticker price of the solution itself. The primary costs come from the ongoing operational overhead of maintaining the data sync pipeline and search infrastructure, the learning curve associated with the solution, and the development effort that goes into building and maintaining search interfaces.

A bolt-on solution requires syncing data (replicating, maintaining consistency and policies to age data out) between your operational database and your search engine — this is undifferentiated work that slows down productivity of your development teams.

Maintaining different technologies to satisfy speed and relevance requirements means more overhead, learning curves and resource specialization needed to have people use and manage different technologies, e.g. a team may choose the operational database functionality for exact match use cases, a full-text search engine to power a website search bar, and a specialized search engine for an internal knowledge base portal.

Search interfaces are notoriously hard to build as they sit at the intersection of design, data, relevance, and high performance. Take something that is as simple as a type-ahead or autocomplete UI.

Autocomplete done right should show relevant suggestions instantly from the first keystroke. Search-as-you-type experiences for popular consumer search sites further leverage telemetry data to show relevant suggestions that are also popular with other users, or take a user’s own past searches into consideration to personalize suggestions. It also needs to consider the design differences inherent to a mobile form factor as compared to a web device.

Problems similar to this apply to the entire search interface: whether it’s detecting search intent (e.g. applying a facet criteria based on user search), merchandising search results, rolling out search relevance strategy changes based on A/B tests, or providing telemetry feedback on user actions.

While getting these problems right can have an invaluable impact, they can often contribute to weeks and months of undifferentiated development/maintenance efforts.

MongoDB Atlas Search: A New Full-Text Search Solution

MongoDB Atlas Search makes it easier for organizations to integrate powerful full-text search capabilities into applications while minimizing backend complexity. Because Atlas Search is fully integrated with MongoDB Atlas, the global multi-cloud database service, there’s no need to replicate data and manage distinct data environments to add search functionality to your app. You have a single system of record and you can avoid setting up, maintaining, and scaling a separate search platform.

Atlas Search works by embedding an Apache Lucene engine on each node of a MongoDB Atlas cluster, and is designed to be simple to use without any extra infrastructure setup involved. You define the field mappings and index options for the documents in a collection, then Atlas Search will index the data and make it available for relevance-based search. Once data is indexed by Atlas Search, you can build search queries using the MongoDB aggregation pipeline. You use the same drivers and query syntax as the database, unifying the developer experience to eliminate context switching between two totally different technologies.

Atlas Search has dozens of search operators you can use to refine your results and craft complex search logic — like autocomplete, filters, and scoring — within a single search operation. Atlas Search also recently introduced Lucene-powered facets in public preview, making faceting and counting 100x faster than before!

With the ReactiveSearch MongoDB Realm project, developers can also create powerful search UIs using the ReactiveSearch and Searchbox UI kits available in React, Vue, JavaScript and React Native. It brings down the time to build consumer-grade search experiences from weeks and months to just days, leaving more time for your development teams to do differentiated work.

The ReactiveSearch UI kit from appbase.io has been used by over a thousand projects to create search UIs for marketplaces, aggregators, SaaS dashboards, and e-commerce storefronts. It comes with over 20 pre-built UI components for search boxes, a variety of list and range facets, results, and maps, or can be integrated with your own design components.

Here’s an app search experience built in ~80 lines of code using ReactiveSearch.

Check out more search UI component demos for numeric and text facets, search-as-you-type experiences, and geo search in React and Vue over here.

Start Building a Better App Search Experience

Sign up for MongoDB Atlas today to start simplifying your application stack. You can try Atlas Search with sample datasets on a free-forever cluster first, then upgrade when you’re ready to power your production applications.

Follow this getting started guide for a guided walkthrough on creating an end-to-end search experiences, or visit the Atlas Search Docs for in-depth references and guides.

Build app search experiences without architectural complexity using MongoDB Atlas Search was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

You can also see the preview of documents matching the query condition before the rule is applied, allowing to have a better control on the actions to apply.

What can you do with Query Rules

Query Rules provide an intuitive way to tailor your search engine’s relevance algorithm to your business needs. You can:

• Promote results or suggestions
• Hide results
• Replace search term or specific parts of the search term (we support regexps making this super powerful)
• Set search intent (e.g. apply a facet) based on the search term
• Set a promotion banner or return any custom data.

Query Rules are really powerful: they can be triggered based on searches on specific indexes, for specific terms or term patterns (thanks to regexps), for specific facet values, by the type of query (e.g. only run query rules for Autosuggestions) as well as run for a specific timeframe (e.g. run these rules for our Holiday specials!)

Moar awesome stuff is coming to Query Rules

We’re also working on an enhancement to allow creating your own JavaScript actions (that run in V8 engine) to modify the search query with full control, or the search results, or to create side effects (e.g. implement saved query functionality). This will be available in preview shortly, feel free to write to us to try this before the general release!

Use Query Rules To Create A More Natural Search Experience

Read more about query rules over here.

Appbase.io is on a mission to enable creating the most demanding app search experiences (we support Elasticsearch and Opensearch engines today), sign up for a 14-day free trial now!

Query Rules: Introducing Preview Rule Effect was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’ve just revamped our onboarding tutorial. If you’re just signing up on appbase.io or looking through our docs, you can try our interactive tutorial out to create a SaaS, E-Commerce or Geo search app without any login or search cluster setup.

Takes only a couple of minutes to create your search app, and you can export the generate code via Codesandbox! 🚀

SaaS search

If you’re building a SaaS search experience, this tutorial uses a TMDB 10,000 movies dataset and walks you through the process of setting searchable fields and facets.

E-Commerce search

If you’re building an E-Commerce search experience, this tutorial uses an E-commerce specific sample dataset and walks you through the process of setting searchable fields and facets.

Geo search

If you’re building a geo search experience, this tutorial uses an earthquakes dataset and walks you through the process of creating a searchable and faceted maps search experience. We use OpenStreetMaps here, but one can also easily choose GoogleMaps to build this out.

These tutorials leverage the React version of ReactiveSearch UI kit which has been used by more than 1,000 projects to create search experiences. We also offer equivalent UI kits for Vue, React Native and Flutter.

Appbase.io offers a point-and-click search relevance control plane, search query rules (promote, hide, rewrite search parameters, return custom data back), out-of-the-box search analytics, stored queries, and caching — features which are beyond the scope of these tutorials. Sign up for our 14-day trial to try these out!

You can deploy appbase.io with any Elasticsearch upstream cluster (Elastic Cloud, AWS OpenSearch) or with appbase.io cloud.

Build your faceted search app in 2 minutes with appbase.io’s interactive tutorials was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’ve open-sourced the ABC import project with our latest 1.0.0 Beta Release 3. The ABC import project has been based on the transporter project from the Compose team.

We’re excited to open-source ABC 🎉:

1. 4 years since the initial release, ABC continues to be used by several of our customers / community users.
2. We’ve struggled to keep up with regular releases for ABC, the last release took a year! Our core focus at appbase.io going forward has on providing the best app search experience, and open-sourcing the project now allows the community to continue relying on it.

Over the past years, we’ve added several new import adaptors as well as maintained support for the existing adaptors.

ABC allows importing data from these sources today:

• CSV
• JSON / JSONL
• MongoDB
• Elasticsearch
• Postgres / MSSQL / MySQL / SQLite
• Kafka
• Redis
• Firestore

With this release, we have also added support for importing data to an OpenSearch cluster.

Key Benefits

1. Whether your data resides in Postgres or a JSON file or MongoDB or in all three places, abc can index the data into Elasticsearch. It is the only tool that allows working with all these sources at once or individually: csv, json, postgres, mysql, sqlserver, mongodb, elasticsearch.
2. It can keep the Elasticsearch index synced in realtime with the data source. Note: This is currently only supported for MongoDB and Postgres.
3. abc import is a single line command that allows doing all of the above. It doesn’t require any external dependencies, takes zero lines of code configuration, and runs as an isolated process with a minimal resource footprint.
4. abc also supports configurable user-defined JS data transformations (think better ETL) for advanced uses to map data types, columns or transform the data itself before the data gets indexed into Elasticsearch.

Data Transformation Examples

Using ABC, you can use data transformations to enrich, transform, or collapse data prior to importing it into Elasticsearch index.

1. Here’s an example showing how to import data from specific tables in a database.
2. Here’s an example that shows how to dynamically import data to different indices.
3. Importing data is a process that needs to be often repeated. Here’s an example showing how to index data with document IDs set from the data itself to avoid duplication of documents.
4. Here’s an example that shows how to set an Elasticsearch index mapping prior to starting the data import.

Data transformation is primarily supported using the goja project — which allows running a JavaScript VM in Go, allowing users to define transformations in JavaScript. Some more example usages of Goja can be found over here.

Get ABC

Download the binary of v1.0.0-beta.3 release for MacOS (both ARM and AMD builds are supported), Linux or Windows. After that, put the binary in a folder of your choice. You can put it in PATH so that it can be called from anywhere. Then test the installation as

> abc version

abc is also available as a docker image.

docker pull appbaseio/abc

Read the following importer specific guides for ABC:

Postgres

CLI for Indexing data from Postgres to Elasticsearch

MongoDB

CLI for Indexing data from MongoDB to Elasticsearch

MySQL

CLI for Indexing data from MySQL to Elasticsearch

Microsoft SQL Server

CLI for Indexing data from MSSQL to Elasticsearch

Elasticsearch

CLI for Indexing data from ElasticSearch to Elasticsearch

JSON

CLI for Indexing data from JSON to Elasticsearch

CSV

CLI for Indexing data from CSV to Elasticsearch

Firestore

CLI for indexing from Firestore to Elasticsearch

Open-sourcing ABC: Import MongoDB, SQL, JSON, CSV, Firestore, Redis Data Into Elasticsearch was originally published in All things #search on Medium, where people are continuing the conversation by highlighting and responding to this story.