# VMind's LLM chart generator, its half-finished env template, and a sample that asks about car brands

> VMind turns a sentence plus a CSV or JSON dataset into a VisActor chart and edits it by dialogue, but the pieces it hands you do not line up: the branch its own links name is not the default branch, the only filled-in endpoint is not the model it calls the default, and the one example prompt asks about car brands against rows of soft drinks.

**VisActor/VMind** — Not only automatic, but also intelligent. An Intelligent  data Visualization System, based on LLM.

- Repository: https://github.com/VisActor/VMind
- Website: https://www.visactor.io/vmind
- Stars: 470 · Forks: 87
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/visactor-vmind

## Every README link names main, but the default branch is develop

The README sends readers to `main` in three separate places: the CONTRIBUTING badge for a first pull request, the LICENSE link, and the pair of npm badges at the top of the file. The branch the repository publishes from is `develop`, so none of those links points at what a visitor lands on by default. Someone who opens the contributor guide from that badge is reading a revision the maintainers may not edit. The same ambiguity carries through the two translated READMEs, `readme-zh.md` and `README-ja.md`, and through `CONTRIBUTING.zh-CN.md`. The top-level tree also carries a bare `option` entry with no file extension, sitting beside the `common/`, `share/` and `tools/` directories and `rush.json`. A contributor who clones the default branch and follows the badge will never be told these two names differ.

## The newest tag is fourteen months older than the last push

Three releases appear in the history: `v2.0.4` on 2025-03-20, `v2.0.5` on 2025-04-07, and `v2.0.8` on 2025-07-11. The spacing widens from eighteen days to three months, then stops. The last push to `develop` is dated 2026-09-22, so nothing in the tree ties a release to what the default branch holds now. Installing `@visactor/vmind` from npm hands you a build cut from July 2025. The gap shows up in the docs too: the newest model string anywhere in the walkthrough is `gpt-4o-2024-08-06`, and whatever landed on `develop` after that release has no tag behind it. Every snippet imports the scoped name `@visactor/vmind`, so the identifier in your code is bound to that package and registry scope.

## The API key is configured from a file under __tests__

Contributor setup is two commands, both driven by Rush:

```bash
# Install dependencies
$ rush update
# Start the VMind development page
$ rush vmind
```

A third command, `rush docs`, starts the documentation page instead, so the repository carries two separate page servers. Neither command touches an endpoint. The README points at `packages/vmind/__tests__/browser/src/pages/DataInput.tsx` as the place to modify the headers sent to the LLM, which puts the credential path inside a browser test fixture that doubles as the demo data input page. The `__tests__` segment says what that file is for, yet it is the one a contributor has to edit by hand. Writing a new `.env.local` file in `packages/vmind` will not change what that component sends, and only the vmind page is described as needing an endpoint at all.

## The .env.local template ends mid-JSON and nests unescaped quotes

The environment template for `packages/vmind` carries eight lines, and only one holds a real address:

```bash
VITE_GPT_URL="Your service url of gpt model"
VITE_GPT_KEY="Your api-key of gpt model"
VITE_DEEPSEEK_URL="https://api.deepseek.com/chat/completions"
VITE_DEEPSEEK_KEY="Your api-key of deepseek model"
VITE_CUSTOM_URL="Your service url of custom model"
VITE_CUSTOM_KEY="Your api-key of custom model"
VITE_CUSTOM_MODEL="Your Custom Model Name"
VITE_PROXY_CONFIG="Your Vite proxy config for forwarding requests. Must be in JSON string format and is optional. Example: {"proxy": {"/v1": {"target": "https://api.openai.com/","changeOrigin": true},"/openapi": {"target": "https://api.openai.com/","ch
```

`VITE_PROXY_CONFIG` describes itself as a JSON string, then opens a bare `{` inside its own double quotes, and the sample stops part way through the second target at the fragment `ch`. Copied as written, that line does not parse. Both proxied paths aim at `https://api.openai.com/`, while the project's own OpenApi link points at visactor.io. Every variable carries the `VITE_` prefix, the Vite convention for values substituted into client bundle code, so a key written there is compiled into the browser page instead of being held on a server. `VITE_CUSTOM_MODEL` is free text with no matching member in the enum further down, so a custom name has to be typed identically in two places.

## One install command for one package, while the charts belong to another

The consumer path starts with a single package:

```bash
# npm
$ npm install @visactor/vmind

# yarn
$ yarn add @visactor/vmind
```

The next step names the default import:

```typescript
import VMind from '@visactor/vmind';
```

The feature list credits the chart narrative work to `@visactor/vchart`, a separate package that neither install command pulls in and that no peer dependency line accompanies. A reader who expects one install to produce a chart component gets the language model layer and has to source the rendering package from elsewhere. The same two install commands appear a second time at the top of the usage walkthrough, with different comments above them, and no pnpm option is offered even though the repository itself builds through Rush. The contributor path and the consumer path therefore do not share a package manager story.

## GPT is called the default, yet DeepSeek is the only endpoint supplied

The feature list says the OpenAI GPT model is used by default and that any other LLM service can replace it. The development template runs the other way: the single filled-in address is `https://api.deepseek.com/chat/completions`, the GPT and custom slots hold the placeholder text "Your service url of gpt model", and the file to edit is named `DataInput.tsx`. Your own choice lands at construction time:

```typescript
import { Model } from '@visactor/vmind';

const vmind = new VMind({
  url: LLM_SERVICE_URL, // URL of the LLM service
  model: Model.GPT4o, // Model to use
  headers: {
    'api-key': LLM_API_KEY
  } //headers will be used directly as the request header in the LLM request. You can put the model api key in the header
});
```

The comment on `headers` says that object is used directly as the request header, with no signing step and no key scoping in between. The `url` you pass decides which service receives your rows, and nothing in the snippet records the resolved address or reports a failed request.

## The Model enum pins 2024 snapshots and lists an advisor among models

Supported models are an enum of ten string values:

```typescript
//models that VMind support
export enum Model {
  GPT3_5 = 'gpt-3.5-turbo',
  GPT3_5_1106 = 'gpt-3.5-turbo-1106',
  GPT4 = 'gpt-4',
  GPT_4_0613 = 'gpt-4-0613',
  GPT_4o = 'gpt-4o-2024-08-06',
  DOUBAO_LITE = 'doubao-lite-32K',
  DOUBAO_PRO = 'doubao-pro-128k',
  CHART_ADVISOR = 'chart-advisor',
  DEEPSEEK_V3 = 'deepseek-chat',
  DEEPSEEK_R1 = 'deepseek-reasoner'
}
```

Three members freeze one dated server release rather than a rolling alias: `gpt-3.5-turbo-1106`, `gpt-4-0613`, and `gpt-4o-2024-08-06`. One is not a hosted model at all, since `CHART_ADVISOR` resolves to `chart-advisor`, the only value without a vendor prefix. Two bake a context window into the identifier itself, `doubao-lite-32K` and `doubao-pro-128k`, in a capital K that nothing else in the file uses. The two DeepSeek members name versions their strings do not pin, because both are the vendor's generic endpoints. Any other string is accepted too, so the enum is a convenience list rather than a gate.

## parseCSVData returns a pair, getFieldInfo returns one field

The two data entry points do not return the same shape. CSV text has to pass through `parseCSVData`, which yields the field metadata and a structured dataset together:

```typescript
// Pass in the CSV string to obtain the fieldInfo and the JSON-structured dataset
const { fieldInfo, dataset } = vmind.parseCSVData(csv);
```

A JSON dataset skips that normalization, and `getFieldInfo` hands back only the field info:

```typescript
// Pass in a JSON-formatted dataset to obtain the fieldInfo
const dataset=[
{
"Product name": "Coke",
"region": "south",
"Sales": 2350
},
{
"Product name": "Coke",
"region": "east",
"Sales": 1027
},
{
"Product name": "Coke",
"region": "west",
"Sales": 1027
},
{
"Product name": "Coke",
"region": "north",
"Sales": 1027
}
]
const fieldInfo = vmind.getFieldInfo(dataset);
```

On the JSON path you keep ownership of the array you passed in and assemble the pair yourself. The four sample rows are all `Coke`, one per region, with `Sales` at 2350 in the south row and 1027 in each of the other three, so any ranking drawn from this sample has a three way tie. The sentence after it asks to show "the changes in sales rankings of various car brands", and that line is also where the walkthrough ends, one clause into the call to `generateChart`, stopping at "the data and dis". The chart types named nearby are line, bar, and pie, with the dynamic qualifier attached only to bar. The promised one-click export to video or GIF has no call and no encoder dependency anywhere in these pages.

## Conclusion

Judge VMind on the branch you actually install. The npm line resolves to a build cut in July 2025 while develop moved on in September 2026, the endpoint and key are yours to supply, and the walkthrough never shows the generateChart call. If a dialogue-driven chart editor fits your stack, install it, pin the tag you verified, keep your endpoint out of a __tests__ fixture, and read the sample dataset as a shape reference rather than a working example.

## FAQ

### What does @visactor/vmind need before it can generate a chart?

An LLM service URL and an API key, handed to the constructor as `url` and as an `api-key` entry inside `headers`. For the development pages the same two values belong in a `.env.local` file inside `packages/vmind`, written as `VITE_GPT_URL` and `VITE_GPT_KEY`.

### Which models are listed in the VMind Model enum?

Ten string values: `gpt-3.5-turbo`, `gpt-3.5-turbo-1106`, `gpt-4`, `gpt-4-0613`, `gpt-4o-2024-08-06`, `doubao-lite-32K`, `doubao-pro-128k`, `chart-advisor`, `deepseek-chat`, and `deepseek-reasoner`. Any other model name can be passed as the `model` value instead.

### How do CSV data and JSON data differ when loading into VMind?

CSV text must go through `vmind.parseCSVData`, which returns both `fieldInfo` and `dataset`. A JSON array goes to `vmind.getFieldInfo`, which returns `fieldInfo` on its own and leaves the array in the caller's hands.

### Which is the newest VMind release, and how old is it compared to the branch?

The newest tag is `v2.0.8`, dated 2025-07-11, following `v2.0.5` on 2025-04-07 and `v2.0.4` on 2025-03-20. The default branch is `develop` and its last push is dated 2026-09-22, so the published build trails the branch by roughly fourteen months.

## Sources

- [License: MIT](https://github.com/VisActor/VMind/blob/develop/LICENSE)
- [Project website](https://www.visactor.io/vmind)
- [README](https://github.com/VisActor/VMind/blob/develop/README.md)
- [Releases](https://github.com/VisActor/VMind/releases)
- [VisActor/VMind on GitHub](https://github.com/VisActor/VMind)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/visactor-vmind