Elasticsearch vs Neo4j Selecting the Right Database for GenAI Applications
As AI-driven applications evolve, the importance of vector search capabilities in supporting these advancements cannot be overstated. This blog post will discuss two prominent databases with vector search capabilities: Elasticsearch and Neo4j. Each provides robust capabilities for handling vector search, an essential feature for applications such as recommendation engines, image retrieval, and semantic search. Our goal is to provide developers and engineers with a clear comparison, aiding in the decision of which database best aligns with their specific requirements.
What is a Vector Database?
Before we compare Elasticsearch vs Neo4j let's first explore the concept of vector databases.
A vector database is specifically designed to store and query high-dimensional vectors, which are numerical representations of unstructured data. These vectors encode complex information, such as the semantic meaning of text, the visual features of images, or product attributes. By enabling efficient similarity searches, vector databases play a pivotal role in AI applications, allowing for more advanced data analysis and retrieval.
Common use cases for vector databases include e-commerce product recommendations, content discovery platforms, anomaly detection in cybersecurity, medical image analysis, and natural language processing (NLP) tasks. They also play a crucial role in Retrieval Augmented Generation (RAG), a technique that enhances the performance of large language models (LLMs) by providing external knowledge to reduce issues like AI hallucinations.
There are many types of vector databases available in the market, including:
- Purpose-built vector databases such as Milvus, Zilliz Cloud (fully managed Milvus)
- Vector search libraries such as Faiss and Annoy.
- Lightweight vector databases such as Chroma and Milvus Lite.
- Traditional databases with vector search add-ons capable of performing small-scale vector searches.
Elasticsearch is a search engine based on Apache Lucene and and Neo4j is a graph database. Both have vector search as an add-on. This post compares their vector search capabilities.
Elasticsearch: Overview and Core Technology
Elasticsearch is an open source search engine built on top of the Apache Lucene library. It’s known for real time indexing and full text search so it’s a go to search for heavy applications and log analytics. Elasticsearch lets you search and analyse large amounts of data fast and efficiently.
Elasticsearch was built for search and analytics, with features like fuzzy searching, phrase matching and relevance ranking. It’s great for scenarios where complex search queries and real time data retrieval is required. With the rise of AI applications, Elasticsearch has added vector search capabilities so it can do similarity search and semantic search, which is required for AI use cases like image recognition, document retrieval and Generative AI.
Vector Search
Vector search is integrated in Elasticsearch through Apache Lucene. Lucene organises data into immutable segments that are merged periodically, vectors are added to the segments the same way as other data structures. The process involves buffering vectors in memory at index time, then serializing these buffers as part of segments when needed. Segments are merged periodically for optimization, and searches combine vector hits across all segments.
For vector indexing, Elasticsearch uses the HNSW (Hierarchical Navigable Small World) algorithm which creates a graph where similar vectors are connected to each other. This is chosen for its simplicity, strong benchmark performance and ability to handle incremental updates without requiring complete retraining of the index. The system performs vector searches typically in tens or hundreds of milliseconds, much faster than brute force approaches.
Elasticsearch’s technical architecture is one of its biggest strengths. The system supports lock free searching even during concurrent indexing and maintains strict consistency across different fields when updating documents. So if you update both vector and keyword fields, searches will see either all old values or all new values, data consistency is guaranteed. While the system can scale beyond available RAM, performance optimizes when vector data fits in memory.
Beyond the core vector search capabilities, Elasticsearch provides practical integration features that makes it super valuable. Vector searches can be combined with traditional Elasticsearch filters, so you can do hybrid search that mixes vector similarity with full text search results. The vector search is fully compatible with Elasticsearch’s security features, aggregations and index sorting, so it’s a complete solution for modern search use cases.
Neo4J: The Basics
Neo4j’s vector search allows developers to create vector indexes to search for similar data across their graph. These indexes work with node properties that contain vector embeddings - numerical representations of data like text, images or audio that capture the meaning of the data. The system supports vectors up to 4096 dimensions and cosine and Euclidean similarity functions.
The implementation uses Hierarchical Navigable Small World (HNSW) graphs to do fast approximate k-nearest neighbor searches. When querying a vector index, you specify how many neighbors you want to retrieve and the system returns matching nodes ordered by similarity score. These scores are 0-1 with higher being more similar. The HNSW approach works well by keeping connections between similar vectors and allowing the system to quickly jump to different parts of the vector space.
Creating and using vector indexes is done through the query language. You can create indexes with the CREATE VECTOR INDEX command and specify parameters like vector dimensions and similarity function. The system will validate that only vectors of the configured dimensions are indexed. Querying these indexes is done with the db.index.vector.queryNodes procedure which takes an index name, number of results and query vector as input.
Neo4j’s vector indexing has performance optimizations like quantization which reduces memory usage by compressing the vector representations. You can tune the index behavior with parameters like max connections per node (M) and number of nearest neighbors tracked during insertion (ef_construction). While these parameters allow you to balance between accuracy and performance, the defaults work well for most use cases. The system also supports relationship vector indexes from version 5.18, so you can search for similar data on relationship properties.
This allows developers to build AI powered applications. By combining graph queries with vector similarity search applications can find related data based on semantic meaning not exact matches. For example a movie recommendation system could use plot embedding vectors to find similar movies, while using the graph structure to ensure the recommendations come from the same genre or era as the user prefers.
Key Differences
Search Implementation and Architecture
Elasticsearch uses Apache Lucene for vector search with an HNSW (Hierarchical Navigable Small World) algorithm. Data is stored in immutable segments and vectors are buffered in memory at index time. Segments are merged periodically for optimization while searching is lock-free during concurrent indexing. Elasticsearch has a guarantee of data consistency across field updates.
Neo4j uses HNSW for vector search, supports up to 4096 dimensions, cosine and Euclidean similarity functions. Quantization is used to reduce memory usage and, since 5.18, relationship vector indexes are supported. You can tune various parameters to balance accuracy and performance, but the defaults should be sufficient for most use cases.
Data Management Capabilities
Elasticsearch shines with real-time indexing and full-text search. It handles vector and keyword field search combined and large amounts of semi-structured data. Aggregations and index sorting and strict consistency during updates makes it great for complex search use cases.
Neo4j takes a different approach, it’s built for graph data relationships. It creates vector indexes on node properties and handles vector embeddings for different data types, text, images, audio. The graph oriented architecture allows for powerful combinations of graph queries with vector similarity, it’s great for relationship based recommendations.
Performance and Scalability
Elasticsearch is very fast, vector search in milliseconds. It’s optimal when vector data fits in memory but can scale beyond memory with some performance trade-offs. It’s concurrent indexing and segment merging approach ensures it’s efficient even under heavy load.
Neo4j’s performance architecture is about flexibility and efficiency. Through parameters like max connections per node and quantization, it optimizes memory usage while keeping search speed. Fast approximate k-nearest neighbor search combined with relationship vector indexes gives robust search across connected data.
Integration Features
Elasticsearch has many integration options, especially great for hybrid search use cases that combines vector similarity with full-text search. It has built-in security features and supports various aggregation methods so it’s a good fit for many use cases.
Neo4j integrates vector search directly into its graph query language. It has specialized procedures like db.index.vector.queryNodes for vector search and allows to combine graph queries with vector similarity. This is especially great for AI powered applications where graph based filtering of vector search results adds an extra dimension to the search.
When to use Elasticsearch
Elasticsearch is the go to for applications that need search across large document sets, especially when you need to combine text search with vector similarity. It’s great for applications like content recommendation systems, semantic document search or large scale log analysis where you need to search millions of documents and have fast response times and multiple search criteria. It’s good when you need to handle high indexing throughput and search availability, so perfect for applications with continuous data ingestion and real time search.
When to use Neo4j
Neo4j is the go to when your application’s core value is in understanding and exploiting relationships between data points. It’s great for applications like social networks, fraud detection systems or recommendation engines where the connections between entities matter as much as the entities themselves. The combination of graph with vector search is particularly powerful when you need to find similar items while considering their relationships and context, like finding similar products in a specific category or patterns in connected data.
Conclusion
Both Elasticsearch and Neo4j have vector search, but they’re good for different use cases. Elasticsearch is great for large scale document search with its mature full text search and efficient vector search, while Neo4j is good for combining relationship based queries with vector similarity search. Your choice should be based on your requirements: choose Elasticsearch if you need document search and can handle large scale data with complex search criteria or choose Neo4j if your application benefits from understanding and querying relationships between data points. Consider your data structure, scale and how central relationships are to your application when you make your final decision.
Read this to get an overview of Elasticsearch and Neo4j but to evaluate these you need to evaluate based on your use case. One tool that can help with that is VectorDBBench, an open-source benchmarking tool for vector database comparison. In the end, thorough benchmarking with your own datasets and query patterns will be key to making a decision between these two powerful but different approaches to vector search in distributed database systems.
Using Open-source VectorDBBench to Evaluate and Compare Vector Databases on Your Own
VectorDBBench is an open-source benchmarking tool for users who need high-performance data storage and retrieval systems, especially vector databases. This tool allows users to test and compare different vector database systems like Milvus and Zilliz Cloud (the managed Milvus) using their own datasets and find the one that fits their use cases. With VectorDBBench, users can make decisions based on actual vector database performance rather than marketing claims or hearsay.
VectorDBBench is written in Python and licensed under the MIT open-source license, meaning anyone can freely use, modify, and distribute it. The tool is actively maintained by a community of developers committed to improving its features and performance.
Download VectorDBBench from its GitHub repository to reproduce our benchmark results or obtain performance results on your own datasets.
Take a quick look at the performance of mainstream vector databases on the VectorDBBench Leaderboard.
Read the following blogs to learn more about vector database evaluation.
Further Resources about VectorDB, GenAI, and ML
Chloe WilliamsChloe Williams is a technical writer at Zilliz.
- What is a Vector Database?
- Elasticsearch: Overview and Core Technology
- Neo4J: The Basics
- Key Differences
- Search Implementation and Architecture
- Data Management Capabilities
- Performance and Scalability
- Integration Features
- When to use Elasticsearch
- When to use Neo4j
- Conclusion
- Using Open-source VectorDBBench to Evaluate and Compare Vector Databases on Your Own
- Further Resources about VectorDB, GenAI, and ML
Content
Start Free, Scale Easily
Try the fully-managed vector database built for your GenAI applications.
Try Zilliz Cloud for FreeThe Definitive Guide to Choosing a Vector Database
Overwhelmed by all the options? Learn key features to look for & how to evaluate with your own data. Choose with confidence.