Kinetica

Editor’s note: This Kinetica review is based on my hands-on evaluation of Kinetica 7.2.3 (the Developer Edition and the free cloud tier) in October 2026. I weighed pricing, setup, spatial, graph and streaming analytics, vector search and SQL-GPT, connectivity, and rivals.

Quick verdict: I recommend Kinetica for fleet-tracking, telecom, defense and logistics teams that want spatial joins, graph routing and vector search in one SQL engine. The trade-off is a closed-source engine and a sales conversation for anything past $1.80/hour.

Kinetica runs geospatial, time-series, graph, vector and streaming analytics in one vectorized, columnar, memory-first engine on CPUs or NVIDIA GPUs. In this review, I’ll take a closer look at Kinetica’s pricing, features, and AI tooling, so you can see exactly whether that consolidation is worth a closed engine.

Key Takeaways:

• Two free options: local Docker (CPU, 8 GB of RAM) and a shared cloud with 10 GB of storage and burstable compute up to 4 cores.
• Spatial, time-series, graph and vector queries share one SQL engine with native Kafka streaming.
• Dedicated Cloud starts at $1.80/hour with no published cluster size; Enterprise is quote-only.
• Multi-user, multi-node and HA replication sit behind paid tiers.
• The engine is closed source, with 40 stars on its largest GitHub repo against ClickHouse’s 50.5k, while HeavyDB is now open source.

Pros and Cons

How Much Does Kinetica Cost?

Kinetica sells three tiers with one public price: a free Developer Edition, Dedicated Cloud at $1.80/hour and a custom-quote Enterprise Edition.

• Developer Edition (free): For personal development. The local Docker install is limited only by your machine and gives you full administrative access. The no-install alternative is a single-node shared serverless cloud with 10 GB of storage and burstable compute up to 4 cores, and it needs no credit card.
• Dedicated Cloud ($1.80/hour): For teams that need a fully managed deployment. It adds multi-user access, GPU acceleration options and multi-node clusters, with Basic support and no external authentication.
• Enterprise Edition (custom quote): For on-premise installs or purchase through the AWS and Azure Marketplaces. It adds external authentication and authorization, full HA replication, custom sizes and Standard or Premium support.

Plan	Price	Deployment	GPU	Multi-user / multi-node	External auth + HA	Support
Developer Edition	Free	Local Docker or shared cloud	Local option; not shared cloud	No	No	Basic
Dedicated Cloud	$1.80/hour starting rate	Fully managed cloud	Optional	Yes	No	Basic
Enterprise Edition	Custom quote	On-premise, AWS, Azure	Available	Yes	Yes	Standard / Premium

All three tiers include time-and-space analytics, graph, real-time analytics, SQL workbooks, Reveal dashboards and UDFs, so the paid tiers buy scale and administration, not features.

Pay-as-you-go license fees depend on cluster size and hours and bill through your cloud provider account. Bring-your-own-license avoids extra Kinetica license charges, but your cloud still bills you for the infrastructure. GPU clusters cost more on both lines: the GPU nodes themselves, plus a higher Kinetica license fee.

Each cluster size step roughly doubles performance, so expect cost to climb in steps rather than smoothly. The $1.80/hour rate carries no published cluster size, so I would get the sizing in writing before signing anything. SingleStore Standard starts at $0.99/hour and StarTree Cloud meters $0.21/hour per production vCPU, so StarTree at least tells you exactly what each hour buys.

Is Kinetica Good Value for Money?

• Good fit: Teams whose spatial joins and graph routing would otherwise need a separate geo service and routing engine next to the database.
• Less convincing fit: Dashboard aggregations with no location or network logic, where open-source ClickHouse does the job without a Kinetica license.
• Budget priority: Price memory, GPU allocation and availability together, because HA replication is Enterprise-only and can decide the purchase on its own.

Reviewer’s Notes: Prototype on the local Developer Edition first: start on CPU, and add --gpu only if you own an NVIDIA card. Move to Dedicated Cloud when you need concurrent users or GPU capacity in the cloud, and ask for an Enterprise quote once external authentication or HA replication becomes a requirement.

My Experience With Kinetica

My Kinetica setup took one shell command and no GPU, which runs against the GPU-database label. Where HeavyDB’s Immerse puts dashboards first, Kinetica started me in a SQL notebook.

Installing the Developer Edition

I gave Docker the 8 GB of RAM minimum (Mac, Linux and Windows are all supported) and ran the CPU install:

curl https://files.kinetica.com/install/kinetica.sh -o kinetica && chmod u+x kinetica && ./kinetica start

With an NVIDIA card, ./kinetica --gpu start takes the GPU path instead. The CPU start needs no GPU at all, but without CUDA there is no VRAM tier, so a CPU trial tells you nothing about GPU memory sizing. For Enterprise GPU installs, Kinetica supports T4, V100, A10, A40, A100, L4, L40 and H100 cards on driver 525.x or higher.

The installer asked me to set the admin password, and I signed in to Workbench at http://localhost:8000/workbench/ as admin. ./kinetica alter-password changes that password later, and ./kinetica stop shuts the instance down. ./kinetica --help lists the rest.

If Docker is off the table, the free shared cloud skips the install entirely: 10 GB of storage, with compute shared between users.

Loading Data in Workbench

I uploaded a CSV to KiFS, the Kinetica file system, from Workbench’s file explorer and ran the Kinetica Filesystem Import wizard on it. The same load works as one SQL statement:

LOAD DATA INTO example.product
FROM FILE PATHS 'kifs://data/products.csv';

Workbooks hold worksheets of SQL and markdown blocks, so the load, the queries and my notes sat in one place. I started from the shipped Quick Start Guide workbook under Examples before touching my own data. For other sources, Workbench also has a general Import/Export Wizard.

Kafka streams get their own Kafka Stream Import wizard, which I cover in the streaming section below.

Asking Questions With SQL-GPT

Every worksheet opens with a SQL-GPT text box. I typed a question in plain English, SQL-GPT wrote a SQL block at the bottom of the worksheet, and I ran it like any other block.

Accuracy depends on a context. I built one with CREATE CONTEXT and attached it to the worksheet through Configure. A context can hold:

• Tables and columns the questions need.
• Rules and annotations that explain business meaning.
• Sample question and SQL pairs that show the query patterns you expect.

Context size is capped at thousands of tokens, so I listed only the columns my questions needed instead of a whole wide schema. The same feature works from plain SQL through GENERATE SQL, GENERATE TOKENS and EXECUTE_AI_QUERY, so generated queries can live in scripts as well as worksheets.

Reviewer’s Notes: SQL-GPT’s default LLM is Kinetica’s SQLGPT.io service, which calls external LLM services. The local SQLAssist LLM requires contacting Kinetica support, so regulated teams should plan that conversation before a single sensitive table goes into a context.

Time and Space Analytics: Geospatial, Time Series and Graph

Kinetica’s engine is vectorized, columnar and memory-first, it spreads work across CPUs and GPUs, and Kinetica has written its own CUDA kernel library since 2009. That design pays off when time-series queries also carry location or network logic, not when they only roll events into hourly totals.

Geospatial Functions and Geo-Joins

Kinetica ingests WKT geometry and runs geo-joins inside ordinary SQL. It ships 23 distinct ST_ geometry functions, with H3 geohashing and tracking functions beside them for movement data.

For maps, Kinetica connects to ArcGIS Real-Time and Tableau geospatial visualization, so a fleet team keeps its existing mapping front end while the database does the spatial math.

ClickHouse has geo functions too, but no built-in routing solvers, and routing is where Kinetica separates itself from engines that only filter by geography.

Graph Solvers and SQL/PGQ

Graph solvers ship built in: /solve/graph runs shortest path (with turn penalties), page rank and other solvers, and /match/graph handles map matching. Routing extends to:

• Isochrones for reachability analysis.
• Multiple supply-demand routing for allocation problems.
• Backhaul routing for return-trip planning.

Version 7.2.3 added SQL/PGQ and GQL graph queries (Cypher-compatible), so graph work can stay in SQL. Fleet routing, telecom network analysis and page rank over NYC taxi data are the use cases Kinetica builds its examples around.

For a dashboard that only counts vehicles by region, the routing engine is not a buying reason.

Tiered Storage: VRAM, RAM, Disk Cache, Persist and Cold

Kinetica moves data across five storage tiers, evicting it downward by strategy:

• VRAM: GPU operations need data here.
• RAM: Host memory.
• Disk Cache: A disk-backed cache tier.
• Persist: Persistent storage.
• Cold Storage: The coldest tier.

Version 7.2 made on-disk storage about 50% smaller, and 7.2.3 added on-disk column compression. Neither changes the GPU math: data a GPU query touches still has to fit in VRAM.

If your queries are mostly flat aggregations with no location or network logic, a general columnar engine does the job for less.

Streaming Ingest and Materialized Views

LOAD DATA with SUBSCRIBE = TRUE turns a Kafka topic into a continuously loading table. I created the Kafka data source first, then subscribed in JSON (Avro and a schema registry are also supported):

LOAD DATA INTO telemetry.events
FORMAT JSON
WITH OPTIONS (
    DATA SOURCE = 'kafka_ds',
    SUBSCRIBE = TRUE
);

Keeping the subscription in SQL means no separate stream-processing app for the common job of feeding analytical tables. A topic of vehicle positions can land in a table that geo-joins and graph solvers read directly, with no ETL hop in between. Kinetica covers other change-capture paths too:

• File change capture: SUBSCRIBE plus POLL_INTERVAL re-checks files on a schedule.
• Remote-query change capture: REMOTE_QUERY_INCREASING_COLUMN tracks incremental progress.
• Workbench stream import: The Kafka Stream Import wizard walks through five steps.
• Outbound changes: Three types of table monitor push table changes out.

Materialized views cache intermediate results in memory and offer four refresh modes:

Refresh mode	Behavior
OFF	Disables automatic refresh
ON CHANGE	Refreshes when underlying data changes
ON QUERY	Refreshes when queried
EVERY n unit	Refreshes on a schedule

Freshness costs memory: a view’s memory and processing grow with its source data, so I would reserve ON CHANGE for views that truly need it. Dropping or altering a source table also drops the view, so every schema migration needs a step that recreates dependent views.

Version 7.2.3 uses native Kafka for HA replication, though full HA stays an Enterprise feature. For tuning, 7.2.1 added a KI_HINT_RECURSIVE_EXPLAIN hint for materialized views.

Apache Druid and Apache Pinot ingest Kafka natively as well, with StarTree Cloud at $0.21/hour per vCPU, so Kafka support alone does not justify Kinetica.

Best for: Streaming dashboards with location or routing logic, such as fleet tracking or telecom network monitoring. Skip if: Event counts and time filters are the whole workload; start with Druid or Pinot.

Vector Search and SQL-GPT: Kinetica’s AI Features

Kinetica 7.2 added a Vector column type with distance functions, plus an Array type with scalar and aggregate functions, a JSON type (14 JSON scalar functions plus JSON_ARRAYAGG) and unlimited-width strings. The distance functions cover:

• Cosine and dot product: COSINE_DISTANCE and DOT_PRODUCT.
• Euclidean distance: EUCLIDEAN_DISTANCE.
• Other metrics: L1, L2, LINF and LP distance.

The 7.2 point releases built on that base:

• 7.2.1, August 2024: Remote models and table functions for generating embeddings, plus a UDF that runs RAG across multiple SQL-GPT contexts.
• 7.2.2, September 2024: An HNSW index for vector similarity search, and OAuth/OIDC single sign-on for Reveal, Workbench and GAdmin (KAgent 7.2.2.0 or later).
• 7.2.3, August 2025: SQL-orchestrated hot backups, on-disk column compression and SQL/PGQ graph queries.

HNSW indexing arrived only in 7.2.2, so run 7.2.2 or later before testing similarity search on a large table.

Remote embedding models can point at OpenAI or NVIDIA NIM endpoints, and vector indexing uses NVIDIA RAPIDS cuVS/CAGRA, so GPU hardware matters for vectors as well as spatial work. If you would rather keep embeddings in-house, a SQL-managed Python UDF can run sentence-transformers inside Kinetica.

SQL-GPT runs through Kinetica’s SQLGPT.io service by default, which calls external LLM services, with the local SQLAssist LLM available by support request. The 7.2.1 RAG UDF picks relevant contexts and tables for each question, but I still read every generated query before running it.

For agents, Kinetica publishes an Apache 2.0 agent-skills repo with SQL, Python SDK and DBA skills, and a LangChain integration connects Kinetica to LangChain agent chains.

The consolidation makes sense when vectors live beside spatial or time-series data. For standalone semantic search, a dedicated vector store or Postgres with pgvector is simpler to run.

Connectivity: Postgres Wire Protocol, Drivers and BI Tools

Kinetica speaks the PostgreSQL wire protocol on port 5432: simple queries are fully supported and extended query syntax is largely supported. I connected with stock Postgres clients:

jdbc:postgresql://<host>:5432/postgres
psql -h <host> -U <username>
psycopg2.connect(host=..., user=..., password=...)

Because extended query syntax is only largely supported, test your application’s prepared statements before any migration. Any tool that already ships a Postgres driver can reach Kinetica, which covers most BI and notebook stacks without a Kinetica-specific install.

Kinetica’s other connection options:

• Native clients: Python, Java, JavaScript/Node, C# and JDBC, all MIT-licensed, plus C++ and Node.js developer guides; the Python client reached v7.2.3.13 on October 1, 2026.
• ODBC and JDBC: A connector guide for applications on either interface.
• BI tools: Tableau (with a separate geospatial visualization guide), Power BI and Esri ArcGIS.
• Built-in dashboards: Reveal, inside Kinetica.
• Database sources: Snowflake and other databases, reachable over JDBC.

That client tag is a patch on the 7.2.3 line: the newest server release is still 7.2.3 from August 2025. GitHub holds the clients and examples, while the engine itself stays closed source. SingleStore speaks the MySQL wire protocol instead, so the driver stack you already run can tip a close decision.

How Does Kinetica Compare to Competitors?

Kinetica wins on spatial, graph, vector and streaming work in one engine; open-source columnar engines win when licensing freedom or plain OLAP matters more.

Tool	Starting price	Open source	Best at
Kinetica	Free Developer Edition; Dedicated Cloud $1.80/hour	Closed engine; MIT clients	Spatial, graph, vector and streaming SQL on CPU or GPU
ClickHouse Cloud	$300 trial credits for 30 days; Basic example about $67/month	Apache 2.0	High-volume columnar aggregations; 50.5k GitHub stars
HeavyDB	Free	Apache 2.0; full platform open-sourced in v10.0.0, October 8, 2026	GPU-rendered geospatial dashboards with Immerse
SingleStore	Free shared workspace; Standard from $0.99/hour	No	Transactions and analytics in one MySQL-compatible database
Apache Druid / Imply Polaris	Druid free; Polaris Starter from $100/month	Apache 2.0	Time-based event analytics at scale
Apache Pinot / StarTree Cloud	SaaS $0.21/hour per production vCPU; BYOC $0.11/hour per vCPU	Apache 2.0	User-facing analytics with high query concurrency
StarRocks	Free open source; commercial support quote-only	Apache 2.0	Fast multi-table joins on lakehouse data

These starting prices are not equivalent capacity: ClickHouse’s Basic figure is a regional example, StarTree meters production vCPUs, and Kinetica leaves the hardware behind its entry rate unstated.

• Kinetica vs ClickHouse: ClickHouse is the better pick for high-volume aggregations without routing or graph needs, and its 50.5k GitHub stars dwarf the 40 on Kinetica’s largest repo. Kinetica earns its place when location and network analysis are central.
• Kinetica vs HeavyDB: HeavyDB comes first for budget GPU geospatial dashboards, since NVIDIA released the full platform as open source in v10.0.0, Immerse and the GPU renderer included, and its repo has 3.1k GitHub stars. Kinetica wins when SQL graph routing and streaming matter more than a dashboard-first workflow.
• Kinetica vs SingleStore: SingleStore suits apps that mix transactions and analytics on MySQL tooling, and its $0.99/hour Standard entry undercuts Kinetica, with Enterprise from $1.49/hour. Kinetica fits better when spatial joins and network solvers drive the evaluation.
• Kinetica vs Apache Druid and Pinot: Druid handles time-based event analytics and Pinot handles user-facing, high-concurrency queries, both with native Kafka ingest. Imply’s Polaris Starter caps storage at 25 GB for $100/month, and Standard runs from $600/month with a 99.9% SLA. Kinetica has to justify itself with spatial, graph or vector requirements, not streaming alone.
• Kinetica vs StarRocks: StarRocks is the stronger pick for multi-table joins over lakehouse data on an Apache 2.0 engine with 12.2k GitHub stars. Kinetica deserves the trial when the same workload also needs routing, map matching or GPU execution.

If open source is a hard requirement, Kinetica drops off the shortlist, because MIT client libraries do not make the engine open. For integrated routing and location analysis, I would trial it alongside HeavyDB.

How I Reviewed Kinetica

I installed the Kinetica 7.2.3 Developer Edition in Docker on CPU, tried the free shared cloud, and worked through Workbench end to end: KiFS file loads, a Kafka subscription, SQL-GPT contexts and the Postgres wire connection from psql, JDBC and psycopg2. I also went through the geospatial functions, graph solvers, vector types and materialized-view refresh modes.

I compared the Developer Edition, Dedicated Cloud and Enterprise tiers on deployment, GPU access, concurrency, authentication and HA, then set Kinetica against ClickHouse, HeavyDB, SingleStore, Druid, Pinot and StarRocks on price, licensing, GitHub footprint and the workload each one wins. I also traced the release line from 7.2 (February 2024) to 7.2.3 (August 2025) to judge how fast the engine moves.

Prices current as of October 2026.

Should You Use Kinetica for Real-Time Spatial and Streaming Analytics?

Kinetica puts spatial joins, graph routing, vector search and streaming SQL in one engine that runs on CPUs or NVIDIA GPUs. It is worth buying when that combination replaces separate systems, not because GPU acceleration sounds fast.

• Logistics, telecom, defense and IoT teams: Yes. Start on the Developer Edition with a representative location-plus-streaming workload.
• AI teams with vectors next to spatial data: Worth a trial, since embeddings and geometry share one SQL engine.
• Plain dashboards or log analytics: ClickHouse or Druid cost less and are open source.
• GPU geospatial dashboards on a budget: Look at HeavyDB first, now that NVIDIA has released the full platform as open source.

Before paying for Dedicated Cloud, get the cluster sizing in writing, and ask about the roadmap, since the server has not had a release since 7.2.3 in August 2025. Your next step: download Kinetica, run the one-line Developer Edition install, and point SQL-GPT at one of your own non-sensitive tables.

FAQs

Is Kinetica free?

Yes, in two forms. The local Developer Edition is free for personal development and limited only by your machine, and the free shared cloud gives you 10 GB of storage and burstable compute up to 4 cores. The shared cloud has no GPU, multi-user access, multi-node clusters or HA replication.

Does Kinetica need a GPU?

No. ./kinetica start runs the local Developer Edition on CPU only, with Docker and at least 8 GB of RAM. An NVIDIA card can use ./kinetica --gpu start. Without CUDA there is no VRAM tier, so test on CPU before you pay for GPU capacity.

How much does Kinetica Dedicated Cloud cost?

Dedicated Cloud starts at $1.80/hour, but Kinetica does not publish the cluster size behind that rate. GPU clusters cost more in both hardware and license fees, and each size step roughly doubles performance. Ask for the exact allocation and billing breakdown before treating $1.80 as a budget.

Is Kinetica open source?

No. The core engine is closed source, while the client libraries are MIT-licensed and the agent-skills repository is Apache 2.0. If you need an open-source GPU database, HeavyDB is the alternative: NVIDIA released its full platform, Immerse included, as open source in October 2026.

Does Kinetica work with PostgreSQL tools?

Yes. Kinetica accepts PostgreSQL wire connections on port 5432, so psql, the PostgreSQL JDBC driver and psycopg2 connect directly. Simple queries are fully supported and extended query syntax is largely supported, so test your application’s own query patterns before relying on full PostgreSQL compatibility.