Flint Chart Language

A semantic chart language that helps AI agents produce polished, editable visualizations across multiple backends.

Stars
★ 4.4k
Last updated
25d ago
License
MIT
Primary language
TypeScript

At a glance

How it runs
Library / SDKMCP serverCLI
Works with
Universal · cross-platformClaude.ai
Cost
Free, no paid service needed
Setup effort
Low · running in minutes
You'll need
Node.js 18+npm or npxAn MCP-capable client for MCP workflowsShell / CLINetwork accessLocal filesystemMCP Server
Typical use
A Claude user with remote custom connectors who wants to discover data and build a chart without leaving the conversation.
Not a fit if
  • Teams needing a released Python package: the port is a source-only preview
  • Teams that must run fully offline: the hosted MCP endpoint needs network access
  • Teams already maintaining native Vega-Lite, ECharts, Chart.js, or Plotly specs directly

What does this agent do, and when should you use it?

Flint is a visualization intermediate language designed to express data fields and chart intent through compact semantic specifications. Its flint-chart TypeScript library accepts a shared ChartAssemblyInput and produces native Vega-Lite, ECharts, Chart.js, Plotly, or Excel output. The accompanying flint-chart-mcp server lets MCP-capable chat and coding clients create, validate, and render charts, returning interactive views, PNG or SVG images, or backend-native specifications. Layout, axes, labels, legends, and marks are derived from the data, chart design, canvas constraints, and an optional visual theme while the source specification remains human-editable. Teams can use a hosted HTTP MCP endpoint or run the server locally; the Python port is currently a source-only preview rather than a released package.

Flint reads rows embedded in data.values; in MCP workflows it can also read local JSON, CSV, or TSV files through data.url. Callers describe fields with more than 70 semantic_types, including Rank, Temperature, Price, and Country, while chart_spec supplies the chart type, encodings, and size. assembleVegaLite, assembleECharts, assembleChartjs, assemblePlotly, and assembleExcel compile that common input into each target's native object. A neighboring theme_spec can select one of ten presets or inherit a preset and override brand-specific decisions. Through flint-chart-mcp, an agent can select a template, validate the specification, render it, open an interactive chart view, return PNG/SVG output, or emit a backend-native specification.

  1. A Claude user with remote custom connectors who wants to discover data and build a chart without leaving the conversation.
  2. A TypeScript developer who needs to generate Vega-Lite, ECharts, Chart.js, or Plotly configurations from one input model.
  3. An analytics team that wants the same dataset delivered as a web visualization or an editable native Excel chart.
  4. A design-system team that wants to define a ThemeSpec once and reuse typography, color, legend, axis, and layout rules across a chart collection.
  5. A user working with large local datasets who wants to run the MCP server locally and read JSON, CSV, or TSV files.
  6. A data-product developer who wants chart sizing, spacing, labels, marks, and legends to adapt to cardinality and canvas constraints.

How do you install or deploy this agent?

Node.js 18 or newer is required. Install the library in a JavaScript or TypeScript project:

npm install flint-chart

Start the local server for agents and MCP clients:

npx -y flint-chart-mcp

For repository development, install the workspaces and run the documented checks:

git clone https://github.com/microsoft/flint-chart
cd flint-chart
npm install
npm run typecheck
npm run test
npm run build
npm run site

The demo site runs at http://localhost:5274/. No API credential is documented. The hosted MCP option requires network access, while local file inputs require the server to have permission to read those files.

How do you use this agent?

Pass data, semantic types, and a chart specification from TypeScript:

import { assembleVegaLite } from 'flint-chart';

const spec = assembleVegaLite({
  data: { values: myData },
  semantic_types: { weight: 'Quantity', mpg: 'Quantity', origin: 'Country' },
  chart_spec: {
    chartType: 'Scatter Plot',
    encodings: { x: { field: 'weight' }, y: { field: 'mpg' }, color: { field: 'origin' } },
    baseSize: { width: 400, height: 300 },
  },
});

Change the output backend without changing the input shape:

import { assembleECharts, assembleChartjs, assemblePlotly, assembleExcel } from 'flint-chart';

const echartsOption = assembleECharts(input);
const chartjsConfig = assembleChartjs(input);
const plotlyFigure = assemblePlotly(input);
const excelArtifact = assembleExcel(input);

A built-in visual theme can be selected alongside the chart specification:

const themedSpec = assembleVegaLite({
  ...input,
  theme_spec: 'economist',
});

A remote MCP client can connect directly to the hosted HTTP endpoint instead of starting a local process:

https://flint.data-formulator.ai/mcp

The documented remote clients are Claude custom connectors and GitHub Copilot in VS Code. The repository recommends a local MCP server for large datasets.

What are this agent's strengths and limitations?

Pros
  • One ChartAssemblyInput targets five backend families, including editable native Excel charts, reducing duplicated backend-specific authoring.
  • More than 70 semantic field types and automatic layout rules use meaning, data cardinality, and canvas limits to derive labels, spacing, marks, and legends.
  • It offers a TypeScript library, hosted HTTP MCP endpoint, local MCP server, and a standalone agent skill for non-MCP workflows.
  • The theme system includes ten presets plus inheritance and overrides for centralized layout, typography, color, axis, and legend decisions.
Limitations
  • Production use requires Node.js 18 or newer, and the Python port remains an unreleased source preview.
  • The theme section states that ThemeSpec currently affects Vega-Lite output, creating a documented limitation for cross-backend visual consistency.
  • Existing systems that directly maintain Vega-Lite, ECharts, Chart.js, or Plotly objects must adopt or translate into Flint's semantic input model.
  • The conversational workflow needs an MCP-capable client; the hosted endpoint adds a network dependency, while local large-data workflows require filesystem permissions.

How does this agent compare with similar options?

Compared with having an agent directly hardcode the verbose parameters of Vega-Lite, ECharts, Chart.js, or Plotly, Flint adds a shared semantic layer that derives scales, axes, spacing, labels, and layout. This enables backend switching from one input, but it also requires adoption of Flint's specification model, and the documented full ThemeSpec effect is currently limited to Vega-Lite output.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Flint Chart Language This agent 60 · Some gaps Library / SDKFree ★ 4.4k 25d ago TypeScript Claude.ai
World Monitor 79 · Good Web appFree + model costs ★ 89k today TypeScript —
Business Analytics Agent 60 · Some gaps Desktop appFree + model costs ★ 2.6k 10d ago JavaScript OpenAI API
QuantDinger AI Trading OS 89 · Good Self-hosted serviceFree + model costs ★ 13k today Python Codex · Claude Code · OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
60/ 100 5-point scale 3.0 / 5
Trust 10/29
Reliability 6/14
Adaptability 12/18
Convention 15/18
Effectiveness 12/13
Verifiability 5/8
Why each dimension lost points
Trust10 / 29 · 1.7/5

CI uses explicit read-only contents permission, and CodeQL permissions are scoped by job, but the evidence does not define least-privilege boundaries for the MCP server at runtime, so least_privilege is only thinly supported. The README says data may be embedded or read from local JSON, CSV, and TSV files and distinguishes hosted from local MCP use, but it gives no hosted-service retention, transport, telemetry, sensitive-data, or action-confirmation policy. No rollback or recovery workflow is documented. External effects are partly identified as opening an interactive view and producing PNG, SVG, native specifications, or Excel output, but their full side-effect boundary is not described. Scheduled CodeQL, constrained CI permissions, and dependency overrides are useful dependency-security measures; no scan results, lockfile, or vulnerability-response evidence was supplied, preventing full marks. The official Microsoft organization, Microsoft Research and IDEAS Lab attribution, copyright notice, and MIT file provide clear, consistent provenance, justifying full source_attribution marks.

Reliability6 / 14 · 2.1/5

The README, package scripts, CI, and tests broadly agree about the principal components and build workflow, while the supplied tests exercise concrete sparse-data, axis-selection, and dodge-planning cases. However, the README says version 0.5.1 extends themes to Plotly and later says ThemeSpec currently affects only Vega-Lite, so self_consistency is not complete. Node 18+, npm commands, workspace scripts, and CI on two Node versions adequately support ordinary dependency availability, but subpackage manifests, a lockfile, and platform or offline constraints were not supplied. There is no evidence of user-facing error messages, diagnostic structure, or recovery guidance, so failure_messages scores zero.

Adaptability12 / 18 · 3.3/5

Library use, hosted and local MCP, chat and coding environments, large datasets, custom themes, multiple rendering backends, and Excel give thorough audience-and-scenario coverage. Backend scope, the source-only Python preview, accepted local file types, and theme applicability provide some boundaries, but the theme statements conflict and unsupported chart types, scale limits, and MCP restrictions are not systematically documented. The MCP is said to expose tools for template choice, validation, and rendering, but no tool schemas, invocation rules, or refusal conditions are included, leaving trigger_precision thin. Node requirements, compatible client examples, a hosted endpoint, local operation, and development commands provide adequate environment fit; complete client configuration is deferred to an external page, so this is not full coverage.

Convention15 / 18 · 4.2/5

The README clearly structures features, installation, library use, themes, MCP, repository layout, development, and contribution paths, earning full information_architecture marks. Installation is concise and includes Node 18+ plus a local-MCP recommendation for large datasets, but full MCP client configuration is deferred elsewhere. Package, component, and assemble API names are consistent in the supplied files, although no compatibility or deprecation policy establishes stronger naming stability. There are several concrete code, agent-prompt, and test examples, but no FAQ or troubleshooting examples. The Python preview and a theme limitation are disclosed, yet limitations are not comprehensive and the theme statements conflict. The complete MIT text matches the README metadata, justifying full license marks. Dated updates, semantic releases, release references, and a changelog path justify full versioning_changelog marks. The official organization, named research groups, contribution guidance, security-reporting path, and CI update path clearly establish maintenance responsibility.

Effectiveness12 / 13 · 4.6/5

Outputs are designed for direct use with Vega-Lite, ECharts, Chart.js, Plotly, Excel, PNG, SVG, and interactive views; editable input specifications and inheritable themes further support usability. A compact semantic input that derives layout and produces several backend-native representations offers clear marginal value over requiring agents to hardcode each backend. MIT licensing, npm/npx installation, and a shared input shape reduce adoption cost, but hosted-service data costs, network dependence, rendering-resource usage, package size, and operational burden are not disclosed, so cost_benefit is not complete.

Verifiability5 / 8 · 3.1/5

Major claims can be traced to named APIs, repository paths, scripts, CI, and tests for specific algorithmic behavior, but core implementations, MCP tool definitions, and output snapshots were not supplied, preventing full claim_traceability. README component claims are corroborated by package.json, CI, and test files, while important claims about all backends, the hosted MCP service, and visual quality lack independent support in the provided evidence. Facts, plans, and recommendations are usually labeled, such as the unreleased Python package and forthcoming paper; however, the arXiv badge versus the statement that a paper is coming soon, along with conflicting Plotly-theme scope statements, weakens complete fact-inference separation.

Risks and how to mitigate them
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Not found in source: sensitive-data handlingUse dedicated, low-privilege, revocable API keys — never production credentials — and keep secrets out of logs.
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • The supplied material does not state the hosted MCP endpoint's retention, logging, telemetry, transport-protection, or sensitive-data policies; verify them before sending non-public data.
  • The MCP can read local JSON, CSV, and TSV files, but no runtime file-access scope, path restriction, or per-read confirmation mechanism is shown; run it with a constrained directory and minimal permissions.
  • The README conflicts on whether ThemeSpec supports Plotly; consult the implementation and backend reference at the assessed revision before relying on that capability.
  • No evidence shows user-facing MCP failure messages, recovery or undo behavior, or complete tool-trigger schemas.
  • This assessment is based only on the supplied static files; installation, tests, rendering, and security scans were not executed.
Evidence confidence: Low Reviewed Aug 14, 2026 Reviewed revision 34ef4516554b New commits since this review; the score may not cover them
See the full review method →

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. 0.5.1
    Release notes excerpt
    flint-chart 0.5.1 Added - Plotly theme support — theme_spec now realizes onto Plotly figures. - Calendar Heatmap chart type for Vega-Lite. Titles - Headlines *and* decks are fitted instead of widening the graphic, with or without a theme. - Axis titles lie flat at the head of their own ruler; units are stated once. Grid and scales - Gridded axes round so the plot edge lands on a grid line, and the grid runs out to its number. - A chart is never left with no way to read a value — where nothing is printed, the grid returns. …
    View on GitHub ↗
  2. 0.5 Flint 0.5: ThemeSpec
    Release notes excerpt
    Flint 0.5 introduces ThemeSpec, a formal specification for applying a coherent design system across an entire chart library. Instead of requiring creators or agents to reproduce design guidance chart by chart, a ThemeSpec participates directly in compilation and adapts to the chart's semantics, data, cardinality, and available space. A ThemeSpec shapes compilation in three stages. Using resolved semantic information, it: - governs layout constraints and dynamics, including density, spacing, sizing, and stretch limits; …
    View on GitHub ↗
  3. 0.4.0 Flint 0.4
    Release notes excerpt
    Update 1: new plotly backend <img width="1240" height="829" alt="image" src="https://github.com/user-attachments/assets/a3514130-ad06-48e8-8458-9e828f6e50f2" /> Update 2: dynamic widget for chart type switch in the mcp server <img width="1090" height="466" alt="image" src="https://github.com/user-attachments/assets/3039761c-6d6c-456b-b6ab-66cf94c8069f" /> Update 3: Research paper Read it here, maybe also share and cite.. [https://arxiv.org/abs/2607.20775](https://arxiv.org/abs/2607.20775) Update 4: new Excel backend …
    View on GitHub ↗

FAQ

Does Flint require a paid service or API key?
The repository is MIT-licensed and documents no API-key requirement or price for the hosted MCP endpoint. It does not provide enough information to promise that hosted access will remain free.
Can Flint run entirely locally?
Yes. npx -y flint-chart-mcp runs the MCP server locally, and flint-chart can be embedded as a TypeScript library. Initially obtaining npm packages normally requires network access.
Can the MCP server read local datasets?
Yes. MCP calls can use data.url for local JSON, CSV, or TSV files, provided the server process has permission to read them. Rows can also be embedded directly in data.values.
Will themes look the same on every backend?
That should not be assumed. An update reports theme support extending to Plotly, while the theme usage section says ThemeSpec currently affects Vega-Lite output, so teams should verify behavior on each intended backend.
What happens when a chart specification is invalid?
The MCP server exposes specification validation and template-selection support, and the repository includes tests and chart-property validation work. The source does not claim that every invalid dataset or backend discrepancy can be repaired automatically.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents