Elasticsearch

When to Use Elasticsearch

• Full-text search on billions of documents
• Complex aggregations (histograms, geo-distance, nested objects)
• Log and event analytics (Elastic stack: ELK)
• Multi-language search with custom analyzers
• Complex relevance tuning (function scoring, scripted scoring)
• Percolator (reverse search: match documents against stored queries)

Meilisearch for product search, Elasticsearch for analytics and petabyte-scale.

Running Elasticsearch

# docker-compose.yml — single node for development
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false # disable for dev; MUST enable in production
      - ES_JAVA_OPTS=-Xms2g -Xmx2g
    ports:
      - '9200:9200'
    volumes:
      - es_data:/usr/share/elasticsearch/data
    ulimits:
      memlock:
        soft: -1
        hard: -1

# Verify
curl http://localhost:9200/_cluster/health?pretty

Mappings (Schema)

Unlike Meilisearch, Elasticsearch requires explicit mappings for production use. Dynamic mappings (auto-detection) cause type conflicts and poor performance.

import { Client } from '@elastic/elasticsearch';

const es = new Client({ node: 'http://localhost:9200' });

// Create index with mappings
await es.indices.create({
	index: 'products',
	body: {
		settings: {
			number_of_shards: 3,
			number_of_replicas: 1,
			analysis: {
				analyzer: {
					product_analyzer: {
						type: 'custom',
						tokenizer: 'standard',
						filter: ['lowercase', 'asciifolding', 'english_stop', 'english_stemmer']
					},
					autocomplete_analyzer: {
						type: 'custom',
						tokenizer: 'standard',
						filter: ['lowercase', 'autocomplete_filter']
					},
					autocomplete_search_analyzer: {
						type: 'custom',
						tokenizer: 'standard',
						filter: ['lowercase']
					}
				},
				filter: {
					english_stop: { type: 'stop', stopwords: '_english_' },
					english_stemmer: { type: 'stemmer', language: 'english' },
					autocomplete_filter: {
						type: 'edge_ngram', // prefix n-grams for autocomplete
						min_gram: 2,
						max_gram: 20
					}
				}
			}
		},
		mappings: {
			properties: {
				id: { type: 'keyword' }, // exact match, no analysis
				name: {
					type: 'text',
					analyzer: 'product_analyzer',
					fields: {
						autocomplete: {
							// sub-field for autocomplete
							type: 'text',
							analyzer: 'autocomplete_analyzer',
							search_analyzer: 'autocomplete_search_analyzer'
						},
						keyword: { type: 'keyword' } // sub-field for exact/sort
					}
				},
				brand: { type: 'keyword' },
				category: { type: 'keyword' },
				description: { type: 'text', analyzer: 'product_analyzer' },
				tags: { type: 'keyword' },
				price_cents: { type: 'integer' },
				in_stock: { type: 'boolean' },
				popularity: { type: 'integer' },
				created_at: { type: 'date' },
				location: {
					type: 'geo_point' // geographic coordinates
				}
			}
		}
	}
});

Indexing Documents

// Single document
await es.index({
	index: 'products',
	id: 'prod-123',
	document: {
		id: 'prod-123',
		name: 'MacBook Pro 14"',
		brand: 'Apple',
		category: 'laptops',
		description: 'M3 chip, 18GB RAM, 512GB SSD',
		tags: ['laptop', 'apple', 'pro'],
		price_cents: 199900,
		in_stock: true,
		popularity: 9500,
		created_at: '2024-01-01T00:00:00Z'
	}
});

// Bulk indexing (preferred for large imports)
const operations = documents.flatMap((doc) => [
	{ index: { _index: 'products', _id: doc.id } },
	doc
]);

const { errors, items } = await es.bulk({ operations });
if (errors) {
	const failed = items.filter((i) => i.index?.error);
	console.error('Bulk index errors:', failed);
}

Query DSL

// Multi-field text search
const results = await es.search({
	index: 'products',
	query: {
		multi_match: {
			query: 'macbook pro',
			fields: ['name^3', 'brand^2', 'description'], // ^N = boost
			type: 'best_fields',
			fuzziness: 'AUTO' // typo tolerance
		}
	},
	from: 0,
	size: 20
});

// Boolean query with filters
const results = await es.search({
	index: 'products',
	query: {
		bool: {
			must: [
				{
					multi_match: {
						query: 'laptop',
						fields: ['name^3', 'description']
					}
				}
			],
			filter: [
				{ term: { category: 'laptops' } },
				{ term: { in_stock: true } },
				{ range: { price_cents: { lte: 200000 } } }
			],
			should: [
				{ term: { tags: 'pro' } } // boost if "pro" tag matches
			],
			boost: 1.0
		}
	},
	sort: [{ _score: 'desc' }, { popularity: 'desc' }]
});

console.log(results.hits.hits.map((h) => h._source));
console.log(results.hits.total.value); // total matching docs

Aggregations

The killer feature over Meilisearch — complex analytics on search results:

const results = await es.search({
	index: 'products',
	query: {
		bool: {
			must: [{ match: { category: 'laptops' } }],
			filter: [{ term: { in_stock: true } }]
		}
	},
	aggs: {
		// Facet counts
		brands: {
			terms: { field: 'brand', size: 20 }
		},

		// Price histogram
		price_ranges: {
			range: {
				field: 'price_cents',
				ranges: [
					{ to: 50000, key: 'under_500' },
					{ from: 50000, to: 100000, key: '500_to_1000' },
					{ from: 100000, to: 200000, key: '1000_to_2000' },
					{ from: 200000, key: 'over_2000' }
				]
			}
		},

		// Statistics
		price_stats: {
			stats: { field: 'price_cents' }
		},

		// Date histogram for charts
		sales_over_time: {
			date_histogram: {
				field: 'created_at',
				calendar_interval: 'month'
			}
		}
	},
	size: 20 // still return documents too
});

console.log(results.aggregations?.brands);
// { buckets: [{ key: 'Apple', doc_count: 45 }, { key: 'Dell', doc_count: 23 }] }

Autocomplete

// Using the edge_ngram field configured in mappings
const suggestions = await es.search({
	index: 'products',
	query: {
		match: {
			'name.autocomplete': {
				query: 'macb', // prefix
				operator: 'and'
			}
		}
	},
	_source: ['name', 'brand'],
	size: 10
});

// Or using completion suggester (faster, purpose-built for autocomplete)
// Requires 'completion' field type in mapping

Production Cluster

# 3-node cluster configuration (each node's elasticsearch.yml)
cluster.name: production-search

# Node 1:
node.name: es-node-1
node.roles: [master, data]
network.host: 10.0.0.10
discovery.seed_hosts: ['10.0.0.10', '10.0.0.11', '10.0.0.12']
cluster.initial_master_nodes: ['es-node-1', 'es-node-2', 'es-node-3']

# Enable security
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true

Sizing:

• Each data node: 32GB RAM minimum for production (ES uses 50% for JVM heap by default)
• JVM heap: -Xms16g -Xmx16g (max 32GB — beyond that G1GC pauses increase)
• SSD storage: ES is I/O intensive

Index lifecycle management (ILM) for log indices:

// Automatically move indices through hot → warm → cold → delete
await es.ilm.putLifecycle({
	name: 'logs-policy',
	policy: {
		phases: {
			hot: {
				actions: {
					rollover: { max_size: '50gb', max_age: '7d' }
				}
			},
			warm: {
				min_age: '7d',
				actions: {
					shrink: { number_of_shards: 1 },
					forcemerge: { max_num_segments: 1 },
					allocate: { require: { box_type: 'warm' } }
				}
			},
			cold: {
				min_age: '30d',
				actions: { freeze: {} }
			},
			delete: {
				min_age: '90d',
				actions: { delete: {} }
			}
		}
	}
});

Choosing Between Meilisearch and Elasticsearch

Use Meilisearch when:
  ✓ Product/content search with typo tolerance
  ✓ Faceted navigation
  ✓ < 100M documents
  ✓ Simple ops (single binary)
  ✓ Fast setup

Use Elasticsearch when:
  ✓ Log analytics (ELK stack)
  ✓ Billions of documents
  ✓ Complex aggregations (geo, date histograms, nested)
  ✓ Custom analyzers per language
  ✓ Percolator / reverse search
  ✓ Multi-index searches