Reindexer — the compact and fast open source
NoSQL in-memory
database for general usage

It's a beautiful, unique, free, open-source solution that combines the best qualities of complex databases and provides better performance

Documentation
Wink Citilink PIK
The Best Project of 2020 RedDot

Features

performance

Performance

Performance —
is our top priority

x2 faster
than other solutions

Memory utilization

Reindexer aims to consume as little memory as possible. Most queries are processed without memory allocation at all

Full text search

Our distinctive feature is the full-text search built into the internal system

Flexible join-queries support

Reindexer supports JOIN and MERGE queries, including their various combinations using logical operations, all within a single query

Clustering

Supports asynchronous replication and database clustering

Persistent storage

Reindexer can store and load documents from disk via LevelDB or RocksDB persistent storage

Geospatial indexes

Supports filtering by points and area intersections using several different engines

Modern interface

Reindexer includes modern GUI that allows easy configuration, monitoring, and viewing your databases

How to use

  • Installation
  • Connectors
  • Docker
    Docker
  • Linux
    Linux
  • MacOS
    macOS
  • Windows
    Windows
  • Sources
    Sources

Container startup

The easiest way to get Reindexer is to pull & run Docker image from DockerHub using the following command
docker run -p9088:9088 -p6534:6534 -it reindexer/reindexer
Copy
See documentation for details.
  • Fedora
  • Ubuntu
  • Debian
  • Redos
  • AltLinux
Choose distros:
  • fedora 41
  • fedora 42
Run the following commands:
yum install -y epel-release yum-utils
rpm --import https://repo.reindexer.io/RX-KEY.GPG
yum-config-manager --add-repo https://repo.reindexer.io/fedora-41/x86_64/
yum update
yum install reindexer-server
Copy
Run the following commands:
yum install -y epel-release yum-utils
rpm --import https://repo.reindexer.io/RX-KEY.GPG
yum-config-manager --add-repo https://repo.reindexer.io/fedora-42/x86_64/
yum update
yum install reindexer-server
Copy
Choose distros:
  • ubuntu noble
  • ubuntu jammy
Run the following commands:
wget https://repo.reindexer.io/RX-KEY.GPG -O /etc/apt/trusted.gpg.d/reindexer.asc
echo "deb https://repo.reindexer.io/ubuntu-noble /" >> /etc/apt/sources.list
apt update
apt install reindexer-server
Copy
Run the following commands:
wget https://repo.reindexer.io/RX-KEY.GPG -O /etc/apt/trusted.gpg.d/reindexer.asc
echo "deb https://repo.reindexer.io/ubuntu-jammy /" >> /etc/apt/sources.list
apt update
apt install reindexer-server
Copy
Choose distros:
  • debian bullseye
  • debian trixie
Run the following commands:
wget https://repo.reindexer.io/RX-KEY.GPG -O /etc/apt/trusted.gpg.d/reindexer.asc
echo "deb https://repo.reindexer.io/debian-bullseye /" >> /etc/apt/sources.list
apt update
apt install reindexer-server
Copy
Run the following commands:
wget https://repo.reindexer.io/RX-KEY.GPG -O /etc/apt/trusted.gpg.d/reindexer.asc
echo "deb https://repo.reindexer.io/debian-trixie /" >> /etc/apt/sources.list
apt update
apt install reindexer-server
Copy
Choose distros:
  • redos-7
  • redos-8
Run the following commands:
rpm --import https://repo.reindexer.io/RX-KEY.GPG
dnf config-manager --add-repo https://repo.reindexer.io/redos-7/x86_64/
dnf update
dnf install reindexer-server
Copy
Run the following commands:
rpm --import https://repo.reindexer.io/RX-KEY.GPG
dnf config-manager --add-repo https://repo.reindexer.io/redos-8/x86_64/
dnf update
dnf install reindexer-server
Copy
Choose distros:
  • P10
The ca-certificates and apt-https packages must be preinstalled to be able to use https repository.
Run the following commands:
echo "rpm https://repo.reindexer.io/altlinux p10/x86_64 reindexer" > /etc/apt/sources.list.d/reindexer.list
apt-get update
apt-get install reindexer-server
Copy
Reindexer can also be installed on macOS using Homebrew
brew tap restream/reindexer
brew install reindexer
Copy
Download installation binary:
You need to download and install 64 bit binary.
Dependencies
Reindexer's core is written in C++20 and uses LevelDB as the storage backend. So, the Cmake, C++20 toolchain, and LevelDB must be installed before the Reindexer installation. Also, FAISS-based vector indexes (IVF in particular) depend on OpenMP and BLAS/LAPACK libraries, but those dependecies are optional - you may build HNWS-only version by passing -DBUILD_ANN_INDEXES=builtin into CMake.

Dependencies can be automatically installed using the script:
curl -L https://github.com/Restream/reindexer/raw/master/dependencies.sh | bash -s
Copy
Build & install
Follow these steps for building and configuring Reindexer:
git clone https://github.com/Restream/reindexer
cd reindexer
mkdir -p build && cd build
cmake ..
make -j4
# install to system
sudo make install
Copy
  • Golang
    Go
  • C++
    C++
  • Java
    Java
  • Python
    Python
  • HTTP REST API
    HTTP REST API
  • GRPC API
    GRPC API
  • PHP
    PHP<community>
  • Rust
    Rust<community>
  • .NET
    .NET<community>

Reindexer for Go is official connector, and maintained by Reindexer's team. It supports both builtin and standalone modes. To enable builtin mode support reindexer-dev should be installed

  • Support modes: standalone, builtin, builtinserver
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes, for builtin and builtinserver
Get connector:
go get -a github.com/restream/reindexer/v5
Copy
See documentation for details.

C++ connector is integrated in main reindexer codebase and will be installed with reindexer-dev package

  • Support modes: standalone, builtin
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes
https://github.com/Restream/reindexer/tree/master/samples/cpp

Reindexer for java is official connector, and maintained by Reindexer's team. It supports both builtin and standalone modes. To enable builtin mode support reindexer-dev (version >= 3.1.0) should be installed. See installation instructions for details

  • Support modes: standalone, builtin, builtinserver
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes, for builtin and builtinserver
To run the installation:
<dependency>
    <groupId>com.github.restream</groupId>
    <artifactId>rx-connector</artifactId>
    <version>[LATEST_VERSION]</version>
</dependency>
Copy
https://github.com/Restream/reindexer-java
Note: Java version >= 1.8 is required

Pyreindexer is official connector, and maintained by Reindexer's team. It supports both builtin and standalone modes. Before installation reindexer-dev (version >= 2.10) should be installed. See installation instructions for details

  • Support modes: standalone, builtin
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes
To run the installation:
pip3 install pyreindexer
Copy
https://github.com/Restream/reindexer-py
https://pypi.org/project/pyreindexer/
Note: Python version >=3.6 is required

The simplest way to use reindexer with any program language - is using REST API. The complete REST API documentation is here. Or explore interactive version of Reindexer's swagger documentation

GPRC is a modern open-source high-performance RPC framework developed by Google that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It uses HTTP/2 for transport, Protocol Buffers as the interface description language and it is more efficient (and also easier) to use than HTTP API. Reindexer supports GRPC API since version 3.0

Reindexer's GRPC API is defined in reindexer.proto file

To operate with reindexer via GRPC:

  1. Build reindexer_server with -DENABLE_GRPC cmake option
    (prebuilt packages from repositories reindexer and reindexer server from official Docker image are built with this option already)
  2. Run reindexer_server with --grpc flag
  3. Build GRPC client from reindexer.proto for your language https://grpc.io/docs/languages/
  4. Connect your GRPC client to reindexer server running on port 16534
Pay attention to methods, that have stream parameters:
rpc ModifyItem(stream ModifyItemRequest) returns(stream ErrorResponse) {}
rpc SelectSql(SelectSqlRequest) returns(stream QueryResultsResponse) {}
rpc Select(SelectRequest) returns(stream QueryResultsResponse) {}
rpc Update(UpdateRequest) returns(stream QueryResultsResponse) {}
rpc Delete(DeleteRequest) returns(stream QueryResultsResponse) {}
rpc AddTxItem(stream AddTxItemRequest) returns(stream ErrorResponse) {}
Copy
The concept of streaming is described here. The best example is a bulk insert operation, which is implemented via Modify method with mode = INSERT. In HTTP server it is implemented like a raw JSON document, containing all the items together, with GRPC streaming you send every item separately one by one. The second approach seems more convenient, safe, efficient and fast

https://github.com/Smolevich/reindexer-client

  • Support modes: standalone, builtin
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes

https://github.com/coinrust/reindexer-rs

  • Support modes: standalone, builtin
  • API Used: binary ABI, cproto
  • Dependency on reindexer library (reindexer-dev package): yes

https://github.com/oruchreis/ReindexerNet

  • Support modes: builtin
  • API Used: binary ABI
  • Dependency on reindexer library (reindexer-dev package): yes

About us

Our goal is to provide fast search with complex queries. We weren't happy with any ready-made solutions and created Reindexer as a more performant alternative

Reindexer is an embeddable, in-memory, document-oriented database with a high-level Query builder interface

Our media

How we chose between Elastic and Tarantool, but made our own (fastest) in-memory database. With Join and full text search (in Russian)
Searching your site with Reindexer is easy. Or how to do "instant search" throughout Habrahabr (in Russian)
Reindexer's porting history - how to conquer Elbrus in 11 days (in Russian)
Reindexer redesign (in Russian)
Database benchmark
Hodo.dev
The replication structure of Reindexer
(in Russian)
Reindexer is very fast in-memory DB with the full-text search (in Russian)
Experience of Reindexer usage (in Russian)

Let's do better

We would be very grateful if you could take part in our survey.
Together we can make the product better

I want to participate
  • Reindexer logo
Apache License 2.0
© 2017-2025 Restream
Copied to clipboard