Choose your tool and connect¶
The standard way to integrate your application with Redis is to use the official Redis clients and libraries for your programming language. Redis ADBC is another option for workflows that benefit from SQL and Apache Arrow, including the data-tool integrations described here.
Start here to install Redis ADBC. The driver requires a Redis RAM database with Search (Query Engine). Redis Software is the default development target; Redis Cloud and supported Redis Open Source deployments also work. Flex, Valkey and Redis 7.2 derivatives are unsupported. See server requirements for versions and ACL permissions. Set QPF to 4× where supported, with sufficient server CPU capacity, for concurrent query performance. Connections use autocommit; transactions are unsupported. Managed tables are the default for SQL/Arrow workflows. Compare managed tables and application-owned data by ownership, freshness and storage cost. Existing application HASHes need copy or adoption before they appear as SQL tables. These operations now create private managed copies; refresh explicitly to observe later application changes. See the current snapshot storage contract before opening an existing database; legacy driver catalogs are not upgraded.
Install without building¶
For native clients such as DuckDB, use the managed native installer for automatic downloads, checksum verification, stable library paths, upgrades and uninstall. The Python wheel path below remains the simplest Python setup.
Use Python 3.14 for current integrations; Python 3.12+ remains installable for the separate Superset compatibility environment. Wheels include the native library for Linux x86-64/ARM64 (glibc 2.28+) and macOS ARM64 (macOS 15+). Windows, macOS Intel and musl Linux have no published wheels. Installing a driver does not start a Redis server.
python -m pip install 'adbc-driver-redis[dbapi]'
python -m adbc_driver_redis doctor --offline
Set REDIS_URI in your application's environment or secret manager. Examples
below read it rather than embedding credentials. Use redis://host:port/0 for
plaintext or rediss://host:port/0 for verified TLS; credentials use
redis[s]://username:password@host:port/0 with URI-encoded reserved characters.
Use the deployment's endpoint and port, rather than assuming 6379.
export REDIS_URI='redis://localhost:6379/0'
python -m adbc_driver_redis doctor
doctor returns 0 when requested checks pass, 1 on a diagnostic failure and 2
for invalid arguments. Without a URI it runs offline. --offline ignores
REDIS_URI; --uri overrides the environment but may expose credentials in
shell history/process arguments. Raw native errors and URI values are not printed.
Online checks open a normal driver connection, including its metadata setup and
recovery, then fetch and validate SELECT 1; they do not explicitly create tables
or ingest sample rows. Read/write timeouts are set to five seconds per command;
connection retries and URI settings can make the total run longer. A successful
plaintext connection does not test TLS. Use your actual rediss:// endpoint to
check TLS, leaving certificate verification enabled.
For a private CA, add --ca-file /path/to/ca.pem; it applies the driver's explicit
trust-bundle option to the direct connection and both manifest discovery checks.
See driver installation for all 50 integrations for the complete package/placement matrix and automated release distributions.
Pick an integration¶
| Tool | Install/configure | Detailed guide |
|---|---|---|
| pandas / Polars | Install the pandas or polars extra; use the bundled driver |
pandas, Polars |
| SQLAlchemy | Install the sqlalchemy extra; use redis+adbc:// or rediss+adbc:// |
SQLAlchemy |
| Superset | Install the superset extra in a separate compatible environment on every web and SQL Lab worker |
Superset |
| Dagster | Install the dagster extra; use RedisADBCIOManager or the documented ADBCResource path |
Dagster |
| DuckDB | Choose the embedded read-only extension or adbc_scanner for catalogs/writes | DuckDB |
| Airflow | Install the airflow extra in every task environment; use RedisAdbcHook |
Airflow |
| Prefect / dlt | Install the corresponding extra and configure the task/destination | Prefect, dlt |
| Ray Data / Dask | Install the corresponding extra in every worker environment | Ray, Dask |
| dbt | Install/configure the separate Redis adapter | dbt adapter |
| Spark / Databricks | Custom Python integration, or evaluate a separate Flight SQL server and JDBC client | Ecosystem comparison |
| Kafka Connect / Flink / Beam / NiFi | Custom integration, or evaluate the tool's JDBC path with Flight SQL | Ecosystem comparison |
| Fabric / Power Query | Custom connector and gateway deployment required; native Windows wheels unavailable | Ecosystem comparison |
| Fivetran / Airbyte / Trino | Custom connectors or separate projects; installing an ADBC wheel alone is insufficient | Ecosystem comparison |
| Snowflake / BigQuery | External ingestion pipeline; driver installation does not create native warehouse federation | Ecosystem comparison |
The dedicated integration guides document runnable examples, version requirements and limitations. The 50-tool ecosystem comparison records test evidence and distinguishes candidate paths from implemented helpers. Repository capabilities may require a newer build than the latest published wheel; check the relevant guide before assuming an installed release includes a helper.
Python DataFrames and DB-API¶
Python clients using this package resolve the bundled library automatically; they do not need manifests. Install pandas or Polars only when using that example.
import os
from adbc_driver_redis import dbapi
with dbapi.connect(os.environ["REDIS_URI"]) as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1 AS one")
print(cur.fetch_arrow_table())
import os
import pandas as pd
from adbc_driver_redis import dbapi
with dbapi.connect(os.environ["REDIS_URI"]) as conn:
print(pd.read_sql("SELECT 1 AS one", conn))
import os
import polars as pl
print(pl.read_database_uri("SELECT 1 AS one", os.environ["REDIS_URI"], engine="adbc"))
To query application data, replace the constant query with a SQL table already
created, ingested or adopted through the driver. The default schema is public.
SQLAlchemy and Superset¶
SQLAlchemy URLs add +adbc to the Redis scheme. This example preserves URI
encoding and TLS when converting an existing Redis URI:
import os
from sqlalchemy import create_engine, text
from sqlalchemy.engine import make_url
url = make_url(os.environ["REDIS_URI"])
if url.drivername not in ("redis", "rediss"):
raise ValueError("Expected redis:// or rediss://")
engine = create_engine(url.set(drivername=url.drivername + "+adbc"))
try:
with engine.connect() as conn:
print(conn.execute(text("SELECT 1 AS one")).all())
finally:
engine.dispose()
In Superset, select the Redis ADBC database type registered by the installed
package. Enter redis+adbc://host:port/0 or rediss+adbc://host:port/0, including
the deployment's credentials using Superset's connection/secret controls. Test
the connection, then select a schema/table and create a dataset. Install in the
application's environment, rather than a separate host Python environment.
See version compatibility and limitations.
DuckDB and other native ADBC clients¶
Register the wheel's library for tools that load drivers by name:
python -m adbc_driver_redis install-manifest --user
python -m adbc_driver_redis doctor --check-manifests
The second command uses REDIS_URI and tests both redis and rediss driver
names against that same endpoint. It verifies discovery and query execution;
it tests TLS only if the endpoint URI uses rediss://.
Use --venv instead of --user for clients using an active Python environment's
manifest directory. A separate DuckDB process must search that location too;
otherwise use user registration or a shared custom manifest directory:
python -m adbc_driver_redis install-manifest --directory /path/to/manifests
export ADBC_DRIVER_PATH=/path/to/manifests
python -m adbc_driver_redis doctor --check-manifests
Manifests contain absolute paths into the installed package. Keep that environment
in place and rerun registration after moving, replacing or deleting it. A service
must run as the same user or receive ADBC_DRIVER_PATH in its own environment.
In DuckDB, after registration:
-- DuckDB 2.0 uses Query.Farm's signed extension repository.
SET allow_extension_repositories = 'allowed';
CREATE EXTENSION REPOSITORY IF NOT EXISTS query_farm
WITH PREFIX 'https://duckdb-extensions.query.farm';
INSTALL adbc_scanner FROM query_farm;
LOAD adbc_scanner FROM query_farm;
ATTACH 'redis://localhost:6379/0' AS r (TYPE adbc, driver 'redis', READ_ONLY);
SELECT * FROM adbc_scan('r', 'SELECT 1 AS one');
DETACH r;
Use your client’s parameter support for credentials. See DuckDB setup
for telemetry settings, writes, schema names and version limits. The standalone
redis_adbc extension embeds the driver and needs
no manifest, and supports SELECT only. Its registry submission has merged; consult the
extension guide for the current DuckDB version and build/distribution requirements.
Do not assume its commands are interchangeable with adbc_scanner.
For native-only installations, download the matching archive and checksum from
GitHub releases, verify
the SHA-256, extract into a stable directory, then run ./install.sh --user there.
The native installer requires Python 3.12+ without additional Python packages.
The Python doctor command requires the Python package; it is not in native tarballs.
For a managed installation, use install, upgrade and uninstall instead of unpacking into a temporary directory. The existing tarball installer remains available for manual library placement.
Airflow¶
Use the package's RedisAdbcHook and the dedicated Airflow guide,
which covers provider compatibility, autocommit handling, worker installation,
connection extras and a runnable TaskFlow DAG. Generic AdbcHook defaults need
special care; use the Redis helper for the documented get_records() behavior.