Top Related Projects
Apache Lucene and Solr open-source search software
⚡️ A fully-featured and blazing-fast JavaScript API client to interact with Algolia.
A lightning-fast search API that fits effortlessly into your apps, websites, and workflow
Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences
🔎 Open source distributed and RESTful search engine.
ZincSearch . A lightweight alternative to elasticsearch that requires minimal resources, written in Go.
Quick Overview
Elasticsearch is a distributed, RESTful search and analytics engine capable of addressing a growing number of use cases. It's built on Apache Lucene and provides a powerful, scalable solution for full-text search, structured search, analytics, and more across various data types.
Pros
- Highly scalable and distributed architecture
- Real-time search and analytics capabilities
- Supports various data types and complex queries
- Rich ecosystem with tools like Kibana for visualization
Cons
- Can be resource-intensive, especially for large datasets
- Complex configuration and tuning for optimal performance
- Steep learning curve for advanced features
- Potential for data loss if not properly configured
Code Examples
- Creating an index and adding a document:
IndexResponse response = client.index(i -> i
.index("customer")
.id("1")
.document(new Customer("John Doe", "johndoe@example.com"))
);
- Performing a search query:
SearchResponse<Customer> response = client.search(s -> s
.index("customer")
.query(q -> q
.match(m -> m
.field("name")
.query("john")
)
),
Customer.class
);
- Aggregating data:
SearchResponse<Void> response = client.search(s -> s
.index("sales")
.size(0)
.aggregations("total_sales", a -> a
.sum(sa -> sa
.field("amount")
)
),
Void.class
);
Getting Started
- Download and install Elasticsearch from the official website.
- Start Elasticsearch:
./bin/elasticsearch - Add the Elasticsearch Java client dependency to your project:
<dependency> <groupId>co.elastic.clients</groupId> <artifactId>elasticsearch-java</artifactId> <version>8.7.0</version> </dependency> - Create a client and start using Elasticsearch:
RestClient restClient = RestClient.builder( new HttpHost("localhost", 9200)).build(); ElasticsearchClient client = new ElasticsearchClient( new RestClientTransport(restClient, new JacksonJsonpMapper()) );
Competitor Comparisons
Apache Lucene and Solr open-source search software
Pros of Lucene-Solr
- Open-source Apache project with a strong community-driven development model
- More flexible and customizable for specific use cases
- Includes Solr, a feature-rich search server built on top of Lucene
Cons of Lucene-Solr
- Steeper learning curve and more complex setup compared to Elasticsearch
- Less out-of-the-box features for distributed search and analytics
- Slower development cycle and release frequency
Code Comparison
Elasticsearch query:
{
"query": {
"match": {
"title": "search example"
}
}
}
Lucene-Solr query:
q=title:search example
Both Elasticsearch and Lucene-Solr are powerful search engines built on the Lucene library. Elasticsearch offers a more user-friendly experience with easier setup and management of distributed systems. It also provides a comprehensive set of features for search, analytics, and visualization out of the box.
Lucene-Solr, on the other hand, offers more flexibility and customization options for advanced users. It includes Solr, which provides additional features like faceting, highlighting, and geospatial search. However, it requires more expertise to set up and manage effectively.
In terms of querying, Elasticsearch uses a JSON-based query DSL, while Lucene-Solr typically uses a more compact URL parameter-based syntax. Both systems support complex queries and offer high performance for large-scale search operations.
⚡️ A fully-featured and blazing-fast JavaScript API client to interact with Algolia.
Pros of algoliasearch-client-javascript
- Lightweight and focused on client-side search functionality
- Easier to set up and use for simple search implementations
- Better suited for small to medium-sized applications
Cons of algoliasearch-client-javascript
- Less flexible and customizable compared to Elasticsearch
- Limited to Algolia's hosted service, potentially higher costs for large-scale applications
- Fewer advanced features for complex search scenarios
Code Comparison
Elasticsearch query:
{
"query": {
"match": {
"title": "search keywords"
}
}
}
Algolia search:
index.search('search keywords', {
attributesToRetrieve: ['title']
});
Summary
algoliasearch-client-javascript is a JavaScript client for Algolia's hosted search service, while Elasticsearch is a full-featured, distributed search and analytics engine. Algolia's client is simpler to use and better suited for smaller applications, but Elasticsearch offers more flexibility, scalability, and advanced features for complex search scenarios. The choice between the two depends on the specific requirements of your project, such as scale, customization needs, and deployment preferences.
A lightning-fast search API that fits effortlessly into your apps, websites, and workflow
Pros of Meilisearch
- Simpler setup and configuration, making it easier for beginners
- Faster indexing and search performance for smaller datasets
- Built-in typo tolerance and relevancy ranking out of the box
Cons of Meilisearch
- Less scalable for very large datasets compared to Elasticsearch
- Fewer advanced features and customization options
- Smaller community and ecosystem of plugins/integrations
Code Comparison
Meilisearch query example:
const search = await client.index('movies').search('batman', {
limit: 10,
attributesToRetrieve: ['title', 'year']
});
Elasticsearch query example:
const result = await client.search({
index: 'movies',
body: {
query: {
match: { title: 'batman' }
},
size: 10,
_source: ['title', 'year']
}
});
Both examples demonstrate a simple search query, but Elasticsearch's syntax is more verbose and offers more fine-grained control over the search parameters. Meilisearch's API is designed to be more straightforward and user-friendly, especially for simpler use cases.
Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences
Pros of Typesense
- Simpler setup and configuration
- Lower resource requirements
- Faster indexing and query performance for certain use cases
Cons of Typesense
- Less mature ecosystem and community support
- Fewer advanced features and customization options
- Limited support for complex queries and aggregations
Code Comparison
Elasticsearch query:
{
"query": {
"match": {
"title": "search example"
}
}
}
Typesense query:
{
"q": "search example",
"query_by": "title"
}
Both Elasticsearch and Typesense are search engines, but they cater to different needs. Elasticsearch is a more comprehensive solution with a wide range of features and scalability options, making it suitable for large-scale enterprise applications. Typesense, on the other hand, focuses on simplicity and ease of use, making it a good choice for smaller projects or those requiring quick setup.
Elasticsearch offers more advanced features like complex aggregations, machine learning capabilities, and extensive plugin ecosystem. Typesense provides a more streamlined experience with out-of-the-box typo tolerance and ranking features.
In terms of performance, Typesense can be faster for certain use cases, especially with smaller datasets. However, Elasticsearch's distributed architecture allows it to handle much larger scale deployments efficiently.
🔎 Open source distributed and RESTful search engine.
Pros of OpenSearch
- Fully open-source and Apache 2.0 licensed, allowing for more flexibility in usage and modification
- Maintains compatibility with Elasticsearch APIs, making migration easier
- Active community development with regular contributions and updates
Cons of OpenSearch
- Newer project with a smaller ecosystem of plugins and tools compared to Elasticsearch
- May lag behind Elasticsearch in terms of cutting-edge features and optimizations
- Potential for divergence from Elasticsearch in the future, which could impact long-term compatibility
Code Comparison
OpenSearch:
public class OpenSearchClient extends RestClient {
public OpenSearchClient(RestClientBuilder builder) {
super(builder);
}
}
Elasticsearch:
public class ElasticsearchClient extends RestClient {
public ElasticsearchClient(RestClientBuilder builder) {
super(builder);
}
}
The code structure for both clients is similar, reflecting OpenSearch's goal of maintaining API compatibility with Elasticsearch. However, specific implementations and advanced features may differ between the two projects.
Both repositories offer powerful search and analytics capabilities, with OpenSearch providing a fully open-source alternative to Elasticsearch. The choice between them depends on specific requirements, such as licensing needs, community support, and long-term development plans.
ZincSearch . A lightweight alternative to elasticsearch that requires minimal resources, written in Go.
Pros of ZincSearch
- Lightweight and easy to set up, with a single binary deployment
- Designed for simplicity and speed, making it suitable for smaller-scale applications
- Built-in web UI for easy management and querying
Cons of ZincSearch
- Less feature-rich compared to Elasticsearch, with fewer advanced functionalities
- Smaller community and ecosystem, potentially leading to fewer resources and integrations
- Limited scalability for very large datasets or complex distributed setups
Code Comparison
ZincSearch query example:
{
"search_type": "match",
"query": {
"term": "example",
"field": "content"
}
}
Elasticsearch query example:
{
"query": {
"match": {
"content": "example"
}
}
}
Both examples show a simple match query, but Elasticsearch offers more complex query options and aggregations for advanced use cases.
Summary
ZincSearch is a lightweight alternative to Elasticsearch, focusing on simplicity and ease of use. It's suitable for smaller projects or those requiring quick setup. However, Elasticsearch remains the more powerful and feature-rich option, with better scalability and a larger ecosystem. The choice between the two depends on the specific requirements of your project, such as scale, complexity, and needed features.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
= Elasticsearch
Elasticsearch is a distributed search and analytics engine, scalable data store and vector database optimized for speed and relevance on production-scale workloads. Elasticsearch is the foundation of Elastic's open Stack platform. Search in near real-time over massive datasets, perform vector searches, integrate with generative AI applications, and much more.
Use cases enabled by Elasticsearch include:
- https://www.elastic.co/search-labs/blog/articles/retrieval-augmented-generation-rag[Retrieval Augmented Generation (RAG)]
- https://www.elastic.co/search-labs/blog/categories/vector-search[Vector search]
- Full-text search
- Logs
- Metrics
- Application performance monitoring (APM)
- Security logs
... and more!
To learn more about Elasticsearch's features and capabilities, see our https://www.elastic.co/products/elasticsearch[product page].
To access information on https://www.elastic.co/search-labs/blog/categories/ml-research[machine learning innovations] and the latest https://www.elastic.co/search-labs/blog/categories/lucene[Lucene contributions from Elastic], more information can be found in https://www.elastic.co/search-labs[Search Labs].
[[get-started]] == Get started
The simplest way to set up Elasticsearch is to create a managed deployment with https://www.elastic.co/cloud/as-a-service[Elasticsearch Service on Elastic Cloud].
If you prefer to install and manage Elasticsearch yourself, you can download the latest version from https://www.elastic.co/downloads/elasticsearch[elastic.co/downloads/elasticsearch].
=== Run Elasticsearch locally
////
IMPORTANT: This content is replicated in the Elasticsearch guide. See run-elasticsearch-locally.asciidoc.
Both will soon be replaced by a quickstart script.
////
[WARNING]
DO NOT USE THESE INSTRUCTIONS FOR PRODUCTION DEPLOYMENTS.
This setup is intended for local development and testing only.
The following commands help you very quickly spin up a single-node Elasticsearch cluster, together with Kibana in Docker. Use this setup for local development or testing.
==== Prerequisites
If you don't have Docker installed, https://www.docker.com/products/docker-desktop[download and install Docker Desktop] for your operating system.
==== Set environment variables
Configure the following environment variables.
[source,sh]
export ELASTIC_PASSWORD="<ES_PASSWORD>" # password for "elastic" username export KIBANA_PASSWORD="<KIB_PASSWORD>" # Used internally by Kibana, must be at least 6 characters long
==== Create a Docker network
To run both Elasticsearch and Kibana, you'll need to create a Docker network:
[source,sh]
docker network create elastic-net
==== Run Elasticsearch
Start the Elasticsearch container with the following command:
[source,sh]
docker run -p 127.0.0.1:9200:9200 -d --name elasticsearch --network elastic-net
-e ELASTIC_PASSWORD=$ELASTIC_PASSWORD
-e "discovery.type=single-node"
-e "xpack.security.http.ssl.enabled=false"
-e "xpack.license.self_generated.type=trial"
docker.elastic.co/elasticsearch/elasticsearch:{version}
==== Run Kibana (optional)
To run Kibana, you must first set the kibana_system password in the Elasticsearch container.
[source,sh]
configure the Kibana password in the ES container
curl -u elastic:$ELASTIC_PASSWORD
-X POST
http://localhost:9200/_security/user/kibana_system/_password
-d '{"password":"'"$KIBANA_PASSWORD"'"}'
-H 'Content-Type: application/json'
// NOTCONSOLE
Start the Kibana container with the following command:
[source,sh]
docker run -p 127.0.0.1:5601:5601 -d --name kibana --network elastic-net
-e ELASTICSEARCH_URL=http://elasticsearch:9200
-e ELASTICSEARCH_HOSTS=http://elasticsearch:9200
-e ELASTICSEARCH_USERNAME=kibana_system
-e ELASTICSEARCH_PASSWORD=$KIBANA_PASSWORD
-e "xpack.security.enabled=false"
-e "xpack.license.self_generated.type=trial"
docker.elastic.co/kibana/kibana:{version}
.Trial license [%collapsible]
The service is started with a trial license. The trial license enables all features of Elasticsearch for a trial period of 30 days. After the trial period expires, the license is downgraded to a basic license, which is free forever. If you prefer to skip the trial and use the basic license, set the value of the xpack.license.self_generated.type variable to basic instead. For a detailed feature comparison between the different licenses, refer to our https://www.elastic.co/subscriptions[subscriptions page].
==== Send requests to Elasticsearch
You send data and other requests to Elasticsearch through REST APIs. You can interact with Elasticsearch using any client that sends HTTP requests, such as the https://www.elastic.co/guide/en/elasticsearch/client/index.html[Elasticsearch language clients] and https://curl.se[curl].
===== Using curl
Here's an example curl command to create a new Elasticsearch index, using basic auth:
[source,sh]
curl -u elastic:$ELASTIC_PASSWORD
-X PUT
http://localhost:9200/my-new-index
-H 'Content-Type: application/json'
// NOTCONSOLE
===== Using a language client
To connect to your local dev Elasticsearch cluster with a language client, you can use basic authentication with the elastic username and the password you set in the environment variable.
You'll use the following connection details:
- Elasticsearch endpoint:
http://localhost:9200 - Username:
elastic - Password:
$ELASTIC_PASSWORD(Value you set in the environment variable)
For example, to connect with the Python elasticsearch client:
[source,python]
import os from elasticsearch import Elasticsearch
username = 'elastic' password = os.getenv('ELASTIC_PASSWORD') # Value you set in the environment variable
client = Elasticsearch( "http://localhost:9200", basic_auth=(username, password) )
print(client.info())
===== Using the Dev Tools Console
Kibana's developer console provides an easy way to experiment and test requests. To access the console, open Kibana, then go to Management > Dev Tools.
Add data
You index data into Elasticsearch by sending JSON objects (documents) through the REST APIs.
Whether you have structured or unstructured text, numerical data, or geospatial data,
Elasticsearch efficiently stores and indexes it in a way that supports fast searches.
For timestamped data such as logs and metrics, you typically add documents to a data stream made up of multiple auto-generated backing indices.
To add a single document to an index, submit an HTTP post request that targets the index.
POST /customer/_doc/1 { "firstname": "Jennifer", "lastname": "Walters" }
This request automatically creates the customer index if it doesn't exist,
adds a new document that has an ID of 1, and
stores and indexes the firstname and lastname fields.
The new document is available immediately from any node in the cluster. You can retrieve it with a GET request that specifies its document ID:
GET /customer/_doc/1
To add multiple documents in one request, use the _bulk API.
Bulk data must be newline-delimited JSON (NDJSON).
Each line must end in a newline character (\n), including the last line.
PUT customer/_bulk { "create": { } } { "firstname": "Monica","lastname":"Rambeau"} { "create": { } } { "firstname": "Carol","lastname":"Danvers"} { "create": { } } { "firstname": "Wanda","lastname":"Maximoff"} { "create": { } } { "firstname": "Jennifer","lastname":"Takeda"}
Search
Indexed documents are available for search in near real-time.
The following search matches all customers with a first name of Jennifer
in the customer index.
GET customer/_search
{
"query" : {
"match" : { "firstname": "Jennifer" }
}
}
Explore
You can use Discover in Kibana to interactively search and filter your data. From there, you can start creating visualizations and building and sharing dashboards.
To get started, create a data view that connects to one or more Elasticsearch indices, data streams, or index aliases.
. Go to Management > Stack Management > Kibana > Data Views. . Select Create data view. . Enter a name for the data view and a pattern that matches one or more indices, such as customer. . Select Save data view to Kibana.
To start exploring, go to Analytics > Discover.
[[upgrade]] == Upgrade
To upgrade from an earlier version of Elasticsearch, see the https://www.elastic.co/guide/en/elasticsearch/reference/current/setup-upgrade.html[Elasticsearch upgrade documentation].
[[build-source]] == Build from source
Elasticsearch uses https://gradle.org[Gradle] for its build system.
To build a distribution for your local OS and print its output location upon completion, run:
./gradlew localDistro
To build a distribution for another platform, run the related command:
./gradlew :distribution:archives:linux-tar:assemble ./gradlew :distribution:archives:darwin-tar:assemble ./gradlew :distribution:archives:windows-zip:assemble
To build distributions for all supported platforms, run:
./gradlew assemble
Distributions are output to distribution/archives.
To run the test suite, see xref:TESTING.asciidoc[TESTING].
[[docs]] == Documentation
For the complete Elasticsearch documentation visit https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html[elastic.co].
For information about our documentation processes, see the xref:docs/README.asciidoc[docs README].
[[examples]] == Examples and guides
The https://github.com/elastic/elasticsearch-labs[`elasticsearch-labs`] repo contains executable Python notebooks, sample apps, and resources to test out Elasticsearch for vector search, hybrid search and generative AI use cases.
[[contribute]] == Contribute
For contribution guidelines, see xref:CONTRIBUTING.md[CONTRIBUTING].
[[questions]] == Questions? Problems? Suggestions?
-
To report a bug or request a feature, create a https://github.com/elastic/elasticsearch/issues/new/choose[GitHub Issue]. Please ensure someone else hasn't created an issue for the same topic.
-
Need help using Elasticsearch? Reach out on the https://discuss.elastic.co[Elastic Forum] or https://ela.st/slack[Slack]. A fellow community member or Elastic engineer will be happy to help you out.
Top Related Projects
Apache Lucene and Solr open-source search software
⚡️ A fully-featured and blazing-fast JavaScript API client to interact with Algolia.
A lightning-fast search API that fits effortlessly into your apps, websites, and workflow
Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences
🔎 Open source distributed and RESTful search engine.
ZincSearch . A lightweight alternative to elasticsearch that requires minimal resources, written in Go.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot