AVA: When Your Data Loads Itself and Tells You What to Ask

You've got a CSV sitting on your disk, a database connection string, or maybe just a blob of text with numbers buried in it. Before you can analyze any of it, you need to write loading code, clean things up, figure out what questions are even worth asking, and then write the visualization code on top of that. What if the tooling handled more of that for you? AVA (AI-native Visual Analytics) is a framework from the AntV team that tries to collapse that whole pipeline—loading, processing, analysis, and visualization code generation—into a single SDK.

What It Does

AVA is a technology framework for visual analytics built around large language models. The name is a bit of a wordplay: the first "A" stands for AI-native, Automated, and Augmented, while "VA" is Visual Analytics. The core idea is that instead of writing rule-based analytics code by hand, you describe your data and your intent, and the framework handles the rest.

Architecturally, it's split into clean modules for data, analysis, and visualization, so you're not forced to adopt the whole thing at once. It runs in two environments: Node.js, where it uses a DuckDB engine for the full feature set, and browsers, where it falls back to an interpreter engine. That dual-environment design means you can do heavy lifting server-side and still ship something interactive to the client.

The workflow is straightforward. You initialize an AVA instance with your LLM configuration, load data from wherever it lives, and then ask the framework to suggest analysis queries based on what it sees in your data.

Why It's Cool

• The loading story is genuinely broad. Most tools make you pick a lane—either files or databases or inline data. AVA's load method takes a type and options and handles CSV files, Parquet, Excel workbooks, JSON object arrays, raw text, and live database connections like MySQL. An Excel workbook even registers one view per sheet automatically. If you've ever written the same CSV-parsing boilerplate for the tenth time, this is the part that'll land.

• It suggests what to query, not just how. The suggest method returns ranked analysis queries with scores and reasons—for example, a question like "What is the average revenue by region?" with a confidence score and an explanation of why it's worth asking. That's a meaningfully different posture from a query builder. It's closer to having someone glance at your schema and say, "here's what I'd look at first."

• Text extraction is a quiet standout. You can pass in something like '杭州 100，上海 200，北京 300' and have it pull structured data out of unstructured text. If your data lives in logs, notes, or scraped pages, that's a real shortcut.

• Node.js gets the serious engine. Defaulting to DuckDB in Node means you're working with a proper analytical database under the hood, not a toy parser. Attaching a MySQL database exposes every table to the LLM, which keeps the mental model simple: connect once, then ask questions.

• LLM config is explicit, not magic. You pass in a model, an API key, and a base URL. No hidden defaults, no vendor lock-in baked into the API surface. You can point it at ling-1t or whatever endpoint you're already using.

How to Try It

Getting started is a two-step affair.

1. Install the package with your preferred manager:

npm install @antv/ava
# or
pnpm install @antv/ava
# or
yarn add @antv/ava

1. Initialize it with your LLM config and load some data:

import { AVA } from '@antv/ava';

const ava = new AVA({
  llm: {
    model: 'ling-1t',
    apiKey: 'YOUR_API_KEY',
    baseURL: 'LLM_BASE_URL',
  },
  // engine: { type: 'duckdb' } is the default in Node
});

// Load a local CSV
await ava.load({ type: 'csv-file', options: { path: 'data/companies.csv' } });

// Or load a remote Parquet file
await ava.load({ type: 'parquet', options: { path: 'https://example.com/data.parquet' } });

// Or attach a MySQL database
await ava.load({ type: 'mysql', options: { host: 'localhost', database: 'mydb', user: 'root', password: 'secret' } });

// Get suggested analysis queries
const queries = await ava.suggest(5);
console.log(queries);

The repository is at github.com/antvis/ava, and there's a website and documentation linked from the README if you want to go deeper. There's also an llms.txt file in the repo, which is a nice touch for anyone feeding docs into an AI coding assistant.

Final Thoughts

AVA is best suited for developers who already have data lying around in mixed formats and want to skip past the plumbing to the interesting part. If you're building internal analytics tools, prototyping data exploration, or just tired of writing the same loader code, the breadth of input types and the query suggestion feature are worth a look. It's not trying to replace your BI stack—it's a framework for the layer between raw data and visualization. The dual-environment support and modular design suggest the team thought carefully about where this fits in a real application, which is usually a good sign.