> ## Documentation Index
> Fetch the complete documentation index at: https://sequinstream.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Get started with Meilisearch
> Learn how to create real-time search indexes from Postgres changes in minutes. Use Sequin to keep your Meilisearch indexes in sync with your database.
In this quickstart, you'll create a real-time data pipeline that streams changes from a Postgres database to a Meilisearch index. You'll:
* Boot Sequin
* Connect to a sample playground database
* Start Meilisearch and create an index
* Set up a sink to sync changes to Meilisearch
* See your changes flow in real-time
By the end, you'll have hands-on experience setting up Postgres change data capture (CDC) with Sequin and Meilisearch.
This is the quickstart for streaming Postgres to Meilisearch. See the [how-to guide](/how-to/stream-postgres-to-meilisearch) for an explanation of how to use the Meilisearch sink or the [reference](/reference/sinks/meilisearch) for details on all configuration options.
The easiest way to get started with Sequin is with our [Docker Compose file](https://github.com/sequinstream/sequin/blob/main/docker/docker-compose.yaml). This file starts a Postgres database, Redis instance, and Sequin server.
1. Download [sequin-docker-compose.zip](https://github.com/sequinstream/sequin/releases/latest/download/sequin-docker-compose.zip).
2. Unzip the file.
3. Navigate to the unzipped directory and start the services:
```bash theme={null}
cd sequin-docker-compose && docker compose up -d
```
```bash theme={null}
curl -L https://github.com/sequinstream/sequin/releases/latest/download/sequin-docker-compose.zip -o sequin-docker-compose.zip \
&& unzip sequin-docker-compose.zip && rm sequin-docker-compose.zip
cd sequin-docker-compose && docker compose up -d
```
```bash theme={null}
git clone git@github.com:sequinstream/sequin.git
cd sequin/docker
docker compose up -d
```
Check that Sequin is running using `docker ps`:
```bash theme={null}
docker ps
```
You should see output like the following:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
bd5c458cabde sequin/sequin:latest "/scripts/start_comm…" 11 seconds ago Up 9 seconds 4000/tcp, 0.0.0.0:7376->7376/tcp sequin-sequin-1
3bacd89765e7 grafana/grafana "/run.sh" 11 seconds ago Up 11 seconds 0.0.0.0:3000->3000/tcp sequin-sequin_grafana-1
3ad41319a66c postgres:16 "docker-entrypoint.s…" 11 seconds ago Up 11 seconds (healthy) 0.0.0.0:7377->5432/tcp sequin-sequin_postgres-1
6139a5fc4e80 redis:7 "docker-entrypoint.s…" 11 seconds ago Up 11 seconds 0.0.0.0:7378->6379/tcp sequin-sequin_redis-1
7e07a5b052de prom/prometheus "/bin/prometheus --c…" 11 seconds ago Up 11 seconds 0.0.0.0:9090->9090/tcp sequin-sequin_prometheus-1
```
Sequin, Postgres, Redis, Prometheus, and Grafana should be up and running (status: `Up`).
The Docker Compose file automatically configures Sequin with an admin user and a playground database.
Let's log in to the Sequin web console:
After starting the Docker Compose services, open the Sequin web console at [http://localhost:7376](http://localhost:7376):
Use the following default credentials to login:
* Email:
```
admin@sequinstream.com
```
* Password:
```
sequinpassword!
```
To get you started quickly, Sequin's Docker Compose file creates a logical database called `sequin_playground` with a sample dataset in the `public.products` table.
Let's take a look:
In the Sequin web console, click **Databases** in the sidebar.
Click on the pre-configured `sequin-playground` database:
The database "Health" should be green.
Let's get a sense of what's in the `products` table. Run the following command:
```bash theme={null}
docker exec -i sequin-sequin_postgres-1 \
psql -U postgres -d sequin_playground -c \
"select id, name, price from products;"
```
This command connects to the running Postgres container and runs a `psql` command.
You should see a list of the rows in the `products` table:
```
id | name | price
----+-----------------------+-------
1 | Avocados (3 pack) | 5.99
2 | Flank Steak (1 lb) | 8.99
3 | Salmon Fillet (12 oz) | 14.99
4 | Baby Spinach (16 oz) | 4.99
5 | Sourdough Bread | 6.99
6 | Blueberries (6 oz) | 3.99
(6 rows)
```
We'll make modifications to this table in a bit.
First, let's start Meilisearch and create an index to store our product data:
Meilisearch offers a docker image that can be run locally. Let's start it up:
```bash theme={null}
docker run -d \
--name meilisearch \
-p 7700:7700 \
-v $(pwd)/meili_data:/meili_data \
getmeili/meilisearch:v1.15 \
meilisearch --master-key=my-api-key
```
Run the following command to create a new index called "products":
```bash theme={null}
curl -X POST 'http://localhost:7700/indexes' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer my-api-key' \
--data '{
"uid": "products"
}'
```
Meilisearch will create the index and infer document structure from inserted data.
You can verify the index was created by listing all indexes:
```bash theme={null}
curl -X GET 'http://localhost:7700/indexes' \
-H 'Authorization: Bearer my-api-key'
```
You should see the `products` index listed.
With the playground database connected and Meilisearch index created, you can create a [sink](/reference/sinks/overview). This sink will send changes to the `products` table to your Meilisearch index:
Click "Sinks" in the sidebar navigation, then click "Create Sink".
Select "Meilisearch" as the sink type and click "Continue".
In the "Source" card, note that the `sequin-playground` database is selected and all schemas and tables are included. Leave these defaults:
In the [Transform](/reference/transforms) card, click the toggle to view existing transforms. None exist, so click "+ Create new transform".
For "Transform name", put `products-meilisearch`. For "Transform type", select "Transform function".
In the "Transform function" field, input the following code:
```elixir theme={null}
def transform(action, record, changes, metadata) do
Map.take(record, ["id", "name", "price"])
end
```
This transform will take the `id`, `name`, and `price` fields from the `products` table and use them to create a new document in Meilisearch.
Click "Create Transform", then select `products-meilisearch` in the transform list.
In the `Inital backfill` card, select the `public.products` table to initate a backfill when the sink is created.
In the Meilisearch card, enter your configuration:
* Host: `http://host.docker.internal:7700`
* Index name: `products`
* Primary key: `id`
* API Key: `my-api-key`
Give your sink a name, like `products-meilisearch`, and click "Create Sink".
The Meilisearch index will first receive a backfill, then will stay in sync in real-time.
With the backfill complete, query Meilisearch for your `products`:
```bash theme={null}
curl -X POST 'http://localhost:7700/indexes/products/search' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer my-api-key' \
--data '{
"q": ""
}'
```
To search for "avocado":
```bash theme={null}
curl -X POST 'http://localhost:7700/indexes/products/search' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer my-api-key' \
--data '{
"q": "avocado"
}'
```
On the new sink's overview page, watch for a green "Health" status.
Now make changes and see them appear in Meilisearch:
```bash theme={null}
docker exec -i sequin-sequin_postgres-1 \
psql -U postgres -d sequin_playground -c \
"insert into products (name, price) values ('Organic Honey (16 oz)', 12.99);"
```
Then search in Meilisearch:
```bash theme={null}
curl -X POST 'http://localhost:7700/indexes/products/search' \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer my-api-key' \
--data '{ "q": "honey" }'
```
```bash theme={null}
docker exec -i sequin-sequin_postgres-1 \
psql -U postgres -d sequin_playground -c \
"update products set price = 7.99 where name = 'Avocados (3 pack)';"
```
```bash theme={null}
docker exec -i sequin-sequin_postgres-1 \
psql -U postgres -d sequin_playground -c \
"update products set name = 'Organic Avocados (3 pack)' where name = 'Avocados (3 pack)';"
```
```bash theme={null}
docker exec -i sequin-sequin_postgres-1 \
psql -U postgres -d sequin_playground -c \
"delete from products where name = 'Blueberries (6 oz)';"
```
Great work!
You've successfully:
* Created a Meilisearch index
* Loaded existing data through a backfill
* Made changes to the `products` table
* Verified changes are flowing to Meilisearch
* Tested search functionality
* Set up a complete Postgres change data capture pipeline
## Ready to stream
Now you're ready to connect your own database to Sequin and start streaming changes:
Connect your Postgres database to Sequin.
Setup a Meilisearch sink to keep your search index in sync.