Permite que agentes de IA façam o perfil de dados e gerem código de gráficos interativos e prontos para produção para projetos em JavaScript, TypeScript ou Python.
Também conhecido como codexguy/regiabi-plugins, regiabi-plugins, @bicharts/chart-mcp
- Stars
- 0
- Ferramentas
- 11
- Downloads, 30 dias
- 8.664
- Versão mais recente
- 0.6.130
- Último commit
- 14 de nov. de 2026
- Licença
- MIT
O que é o MCP RegiaBI?
Permite que agentes de IA façam o perfil de dados e gerem código de gráficos interativos e prontos para produção para projetos em JavaScript, TypeScript ou Python. Ele expõe 11 ferramentas, como assess_data_shape, get_guide, list_eligible_charts.
Resumo gerado a partir do README do projeto
Sobre o MCP server de RegiaBI
O RegiaBI apps fornece um MCP server projetado para ajudar desenvolvedores a transformar dados brutos em visualizações interativas e prontas para produção. Ao se conectar a clientes de IA como Claude Code, GitHub Copilot CLI ou Gemini CLI, o servidor permite que agentes analisem datasets e recomendem tipos específicos de gráficos. Ele suporta projetos JavaScript e TypeScript usando D3, bem como projetos Python usando Plotly ou matplotlib.
Os usuários podem executar o servidor localmente via npx ou se conectar a uma versão hospedada. Para execução local, o servidor realiza o profiling dos dados na sua máquina usando a ferramenta assess_data_shape, garantindo que linhas sensíveis não saiam do seu ambiente. Ao gerar gráficos, o sistema utiliza um mecanismo de elegibilidade para classificar aproximadamente 90 tipos de gráficos com base no que os dados realmente podem representar. Enquanto o profiling é gratuito, a geração de código requer uma conta RegiaBI, que pode ser autenticada via login no navegador ou por uma chave de licença fornecida através de variáveis de ambiente ou um arquivo de credenciais.
O que você pode fazer com ele
- 1Perfil de datasets locaisPeça ao seu agente para analisar um arquivo CSV para determinar sua estrutura e cardinalidade sem fazer o upload das linhas reais.
- 2Identificação de visualizações compatíveisSolicite uma lista de tipos de gráficos que sejam matemática e logicamente apropriados para um dataset específico.
- 3Construção de Microsoft Fabric AppsUse o servidor para encontrar visualizações naturais dentro de um modelo semântico para sugerir gráficos apropriados para uma aplicação de dados.
Escrito a partir do README do projeto. Cada caso de uso é verificado com uma citação dele.
Como instalar o MCP RegiaBI
Formatos verificados em 10 nov 2026Adicionar ao CursorAdicionar ao GooseInstalar o MCP RegiaBI no Claude Code
$ claude mcp add --env 'BIC_LICENSE_KEY=<YOUR_BIC_LICENSE_KEY>' --env 'BIC_SECRET_KEY=<YOUR_BIC_SECRET_KEY>' regiabi-plugins -- npx -y @bicharts/chart-mcpInstalar o MCP RegiaBI no Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"regiabi-plugins": {
"command": "npx",
"args": [
"-y",
"@bicharts/chart-mcp"
],
"env": {
"BIC_LICENSE_KEY": "<YOUR_BIC_LICENSE_KEY>",
"BIC_SECRET_KEY": "<YOUR_BIC_SECRET_KEY>"
}
}
}
}Instalar o MCP RegiaBI no VS Code
.vscode/mcp.json
{
"servers": {
"regiabi-plugins": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@bicharts/chart-mcp"
],
"env": {
"BIC_LICENSE_KEY": "<YOUR_BIC_LICENSE_KEY>",
"BIC_SECRET_KEY": "<YOUR_BIC_SECRET_KEY>"
}
}
}
}Instalar o MCP RegiaBI no VS Code CLI
$ code --add-mcp '{"name":"regiabi-plugins","type":"stdio","command":"npx","args":["-y","@bicharts/chart-mcp"],"env":{"BIC_LICENSE_KEY":"<YOUR_BIC_LICENSE_KEY>","BIC_SECRET_KEY":"<YOUR_BIC_SECRET_KEY>"}}'Instalar o MCP RegiaBI no Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"regiabi-plugins": {
"command": "npx",
"args": [
"-y",
"@bicharts/chart-mcp"
],
"env": {
"BIC_LICENSE_KEY": "<YOUR_BIC_LICENSE_KEY>",
"BIC_SECRET_KEY": "<YOUR_BIC_SECRET_KEY>"
}
}
}
}Instalar o MCP RegiaBI no Codex
$ codex mcp add regiabi-plugins --env 'BIC_LICENSE_KEY=<YOUR_BIC_LICENSE_KEY>' --env 'BIC_SECRET_KEY=<YOUR_BIC_SECRET_KEY>' -- npx -y @bicharts/chart-mcpInstalar o MCP RegiaBI no Codex config.toml
~/.codex/config.toml
[mcp_servers.regiabi-plugins] command = "npx" args = ["-y", "@bicharts/chart-mcp"] [mcp_servers.regiabi-plugins.env] BIC_LICENSE_KEY = "<YOUR_BIC_LICENSE_KEY>" BIC_SECRET_KEY = "<YOUR_BIC_SECRET_KEY>"
Instalar o MCP RegiaBI no Gemini CLI
$ gemini mcp add -s user -e 'BIC_LICENSE_KEY=<YOUR_BIC_LICENSE_KEY>' -e 'BIC_SECRET_KEY=<YOUR_BIC_SECRET_KEY>' regiabi-plugins npx -- -y @bicharts/chart-mcpInstalar o MCP RegiaBI no Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"regiabi-plugins": {
"command": "npx",
"args": [
"-y",
"@bicharts/chart-mcp"
],
"env": {
"BIC_LICENSE_KEY": "<YOUR_BIC_LICENSE_KEY>",
"BIC_SECRET_KEY": "<YOUR_BIC_SECRET_KEY>"
}
}
}
}Iniciado pela HostedMCP em 16 de nov. de 2026
Rodamos este comando para @bicharts/chart-mcp 0.6.130 em um contêiner isolado, sem rede e sem chaves. Ele respondeu e listou 11 ferramentas.
Ferramentas do MCP RegiaBI 11
Lido do servidor com tools/listassess_data_shapeSomente leituraProfile a dataset locally (no data leaves the machine): per-column types, cardinality, ranges, measure/dimension roles, temporal/ordinal detection, and cross-column signals (nesting, shared values, association). This is the same measurement engine the BIC Power BI visual uses before generating a chart.
get_guideSomente leituraHow to build an app with these charts, from the guide this package ships. Local and free: no network, no credentials. topic 'fabric-app' (the default) is what a Microsoft Fabric App on the Rayfin data app template needs: what to pull, generating, wiring in React, the Fabric App section and the time-savers. 'all' is the whole guide, including Blazor. 'chart-shapes' lists every chart type with the columns, limits and renderers it needs. 'settings' lists the choices a person can make about a chart, with their options and defaults.
list_eligible_chartsSomente leituraThe AUTHORITATIVE list of chart types (maps, tables a reader works with and app widgets included) that can render this dataset — the server's own eligibility engine, NOT a local guess. Profiles the data locally, then sends that profile to the backend. NO LLM in the loop, but this is a NETWORK call and it is METERED — see the licensing note below. By default the tool DETECTS the project's language (JS/TS vs Python from the working dir) and returns the charts for THAT language, SCOPED and ordered by how well each type fits this data (best first; `order: 'variety'` favors newer and less-common types instead), each tagged with its source language and renderer. Pass `language` ('javascript'|'python') to force it, or `renderer` ('D3'/'PLOTLY'/…) to rank one specific renderer, or renderer '' for the full renderer-agnostic eligibility across ALL renderers (also ranked, by chart type alone, with no renderer/language tag). If the language can't be auto-detected and none is given, the tool asks you to specify one. Needs an account: eligibility IS the engine, so programmatic access to it is licensed. With nothing configured, the first call opens a browser sign-in, waits for it and then answers (a license key in the environment is the alternative for a machine with no browser). Free within a generous hourly allowance; beyond it each call draws usage credits. The reply carries a text block and a structured table: one row per chart type with its rank, name, preview flag, fit verdict, description, language and renderer. Rows flagged alsoWorthALook are a few picks from below the top fits, drawn so an offer can include something different; the fit order itself never changes. A type that fits only once the rows are totalled (raw rows where the chart wants one per category) is listed under its own heading, once per grain: each row carries the sentence that says how the rows are totalled first and that grain's projection key.
generate_chartAçãoGenerate ready-to-render chart code for a dataset via the BIC backend: the data shape is profiled locally, the backend picks a suitable chart type (or honors chart_type), and returns code that has passed the backend's eligibility gates and quality checks. Needs a trial or paid account: with nothing configured, the first call opens a browser sign-in, waits for it and then finishes the chart (a license key in the environment or ~/.bic/credentials.json is the alternative for a machine with no browser). The returned D3 code is a portable render(container, data, options) function meant to be MERGED into your own app; an integration contract describes exactly how to call it. A standalone HTML preview and file output are optional. The arguments chart_style, level_of_detail and culture are the person's choices, and the guide's 'settings' topic lists every choice a person can make with its options.
preview_requestSomente leituraShows exactly what a chart generation would send to the BIC backend for these arguments - the measured shape of your data (column names, types, counts, ranges), the settings, and whether any sample rows travel - with the credentials removed. SENDS NOTHING and needs no license: it is local and free. Takes the same arguments as a generation. It answers 'what data leaves my machine?'; the eligibility list sends a subset of the same shape.
check_requestSomente leituraChecks a chart request against this data before anything is generated. Takes the same arguments as a generation - the chart type and every setting (date grain, limit, overlay, required columns, rows policy, data labels and the rest) - and answers, in the server's own words, each ask this data can't honor and why: a channel the data doesn't have, too little of one for the ask, or a name the catalog doesn't know. When the chart type itself is denied, it also lists up to five chart types that fit this data, best fit first. An OK names the asks it checked. Profiles the data locally and sends that profile, as a generation would; no sample rows travel. NO LLM in the loop and no generation credits are spent, but this is a NETWORK call and it is METERED like the eligibility list: free within a generous hourly allowance, then usage credits per call. Needs an account: with nothing configured, the first call opens a browser sign-in (a license key in the environment is the alternative). The reply carries a text block and a structured result: the verdict (OK or DENY), the asks checked, each finding with its kind and reason, and the alternatives.
check_chartSomente leituraVerify a generated chart locally before deploying: draws the chart.js that generate_chart wrote, headless, against its data - the rows query_semantic_model saved, a CSV, or the rows it was generated for - through @bicharts/chart-host, and reports in plain words: the marks drawn by kind, anything thrown (with the line), whether it came out blank, anything drawn outside its frame, and whether a click on a mark reaches onSelect with source rows. Takes seconds; local and free (no network, no credentials, nothing sent). Run it after each generate_chart instead of deploying to see whether a chart works, and check at the size the panel will give it: by default it reads minChartWidth and minChartHeight off the app's BicChartPanel around the chart (else the size it was generated for); pass width and height only for another size. A WARNING line is a label cut off at that size even at a narrow font's width; the reply says whether more room fixes it. The app's own legend and frame fit is NOT run in the check, so a label it flags may already be handled in the app. Never edit the generated chart code by hand to clear a finding: regenerate it (generate_chart, with a prompt describing the fix) or report it. It does not judge colors or real font widths.
check_appSomente leituraCheck how the app uses the chart library, before every deploy and after check_chart: reads the app's own source (never the files generate_chart and setup_fabric_app wrote) and reports, each with file, line and the library call to use instead: hand-written selection glue (a toggle, a second-click guard, a remount to clear) where useBicFilter + selects does it; each chart's filter wiring - the page filter its clicks set and the filters its query or component follows (filtered query, highlight only or none) - with a chart filtered by the filter it sets, a treatAs column the model's relationships can't carry to the panel, or to one of its measures (read from the tables each measure's expression reads) (read from the project's schema cache, .schema/models/*/model.sqlite), a total that isn't the sum of the parts the page shows (a rounding measure at the total), a click filter keyed coarser than the marks that set it, a chart carrying write markers whose query drops rows the write form can target, several charts sharing one click filter, a chart no page filter reaches, and a panel whose filtered query it isn't given; a "vs" measure in the app's .dax queries that is never blank (BLANK() - 1 is -1), a card that names a window ("2019 to 2025") over a query with no bound on it, and a query a line over time reads that can drop a quiet period (SUMMARIZECOLUMNS with no COALESCE or ADDMISSINGITEMS), a query whose range is a date written in (DATE ( y, m, d )) where it should come from the data or the person's words; a write that stores a placeholder name ("unknown") when no one is signed in or a time from the browser's clock, a Rayfin entity that takes any name on create or lets any row be updated again (rayfin/data), a name shown (createdBy) its policy doesn't check against the caller's token, a function that reads the caller's email from preferred_username or upn (Rayfin reads only the email claim), a write that resolves before its reload lands (so its button comes back on over the old rows), reloads applied out of order, a list that can't tell loading from empty, a form default read once, a due date with no lower bound, a due date the server refuses by UTC's today (or its own) while the form's min is the reader's date, a read of every row on every open, a panel with no Retry, a write that only a chart pick can aim (no searchable picker), a list for a picked owner filtered on another owner field than the form saves, a sign-in check weaker than the save's, a lookup whose rows feed the page while its loading and failure show only in a dialog, a blank value put into text with String() ("null"), saved rows never reloaded when the page comes back into view, a done-once write that reloads only on success, a dialog list copied into state when it opened, and a dialog that doesn't hold the keyboard; light and dark: no light/dark toggle, the template's theme hook (it flips a reader's pick back), a color written as a literal where a theme token belongs, and a dialog scrim that washes the page in one theme; a card's static text that states an order the reader can change ("highest first"); a page filter read as its first key only (`.value`), where a group pick holds several; row positions read from the DOM; the payload's __rowIdx__ / __geo* columns built by hand; a slider beside a chart that draws its own controls (useBicControls); notes kept but never shown on the marks (annotations); a chart outside a BicChartPanel, a fixed height below the panel's minimum, a fixed card height whose title and subtitle (wrapped at a phone's width) leave its chart under its minimum, a minChartWidth wider than a phone gives a chart (294px) and than the chart type's own minimum, a chart's card narrower than its chart's minimum at any page width from 1024 to 1920px (worked out from the page's grid), a flex-1 container without min-h-0 / min-w-0; two charts setting the same element id; a chart that judges a measure good or bad but was generated with no direction of good; an installed @bicharts/chart-host older than the generated components need (0.6.86); and @bicharts / Rayfin / Fabric visuals packages behind npm's latest. It also draws every chart under src/charts the way check_chart does and reports any that throw, come out blank or don't pass a click to onSelect. Local and free; npm is only asked for versions, and a stack finding is skipped when npm can't be reached. Layout findings are WARNINGS: a static read can't prove a layout. Fix the app's own files; regenerate a chart rather than edit its generated code.
setup_fabric_appAçãoRun once in a Microsoft Fabric App scaffolded from Rayfin's data app template, before the first chart: installs @bicharts/chart-host (at this server's version) and d3, adds src/lib/bic-chart-options.ts (the app's Fabric theme as chart options) and src/components/bic-chart-panel.tsx (a chart box that measures itself and shows the query's loading, error and empty states) and .agents/skills/regiabi-charts/SKILL.md (also written to .claude/skills/, where Claude Code reads it), ignores .bic/, and puts every @microsoft/rayfin-* package on npm's latest, the release `rayfin init` installs (run it before rayfin init; every package.json range it changes is listed, and the reply names the Rayfin version installed). Never overwrites a file; the one template file it edits - a vi.mock that fixes the template's own validate-visual test under ESM - is named in the reply, as is the one line of src/main.tsx it points at src/lib/bic-css-theme.ts (the theme without bundling Vega). With features: ["notes"] and/or ["scenarios"] (once Rayfin's data service is on), it also adds finished notes-on-marks and saved-scenario files - the Rayfin entities, registered in rayfin/data/schema.ts, a hook each, a notes dialog and a scenarios panel - built on chart-host's useBicFilter / useBicControls; write none of that by hand. Replies with a worked example that renders a generated chart from a live query.
query_semantic_modelAçãoIn a Microsoft Fabric App built on Rayfin's data app template: runs one chart's DAX query through the project's own tooling - its semantic model's Rayfin connector (rayfin/rayfin.yml), or on the template's older layout its `fabric-app-data` CLI - renames the `Table[Column]` and `[Measure]` headers to plain names (the names the chart.component.tsx that generate_chart writes will match on live rows), saves EVERY row as CSV, reads each column's role, format and description from the model, and profiles the result. Replaces the query, rename, save and profile steps with one call, and returns the arguments to pass to list_eligible_charts and generate_chart. Write the query at the chart's grain (one row per country for a country map). Local: the data goes only where the project's own tooling already sends it, and nothing reaches the chart server.
suggest_chartsAçãoWhich charts suit this data? Answers 'what are good chart types for this dataset / model', 'what can I chart here', 'recommend some charts' for a semantic model in a Microsoft Fabric App built on Rayfin's data app template, in ONE call, from the model's real rows: reads its tables, columns, measures and relationships through the project's own tooling (its Rayfin connector, or the older layout's `fabric-app-data` CLI), finds its natural views (measures by place, flows between places, measures over time, measures by category), queries each at its grain, keeps the measures that vary there, and asks the server's eligibility engine what fits each view. Replies view by view with the real counts (rows, places, periods, categories) and the chart types that fit, and saves each view's rows and DAX under .bic/data so generate_chart can build any of them next. Pass `views` to ask about your own groupings. Answer the person from this reply rather than from general knowledge. One eligibility call per view: metered like list_eligible_charts (free within an hourly allowance, usage credits beyond it) and needs the same license. For one table you already hold, use list_eligible_charts.
| assess_data_shape | Profile a dataset locally (no data leaves the machine): per-column types, cardinality, ranges, measure/dimension roles, temporal/ordinal detection, and cross-column signals (nesting, shared values, association). This is the same measurement engine the BIC Power BI visual uses before generating a chart. | Somente leitura |
| get_guide | How to build an app with these charts, from the guide this package ships. Local and free: no network, no credentials. topic 'fabric-app' (the default) is what a Microsoft Fabric App on the Rayfin data app template needs: what to pull, generating, wiring in React, the Fabric App section and the time-savers. 'all' is the whole guide, including Blazor. 'chart-shapes' lists every chart type with the columns, limits and renderers it needs. 'settings' lists the choices a person can make about a chart, with their options and defaults. | Somente leitura |
| list_eligible_charts | The AUTHORITATIVE list of chart types (maps, tables a reader works with and app widgets included) that can render this dataset — the server's own eligibility engine, NOT a local guess. Profiles the data locally, then sends that profile to the backend. NO LLM in the loop, but this is a NETWORK call and it is METERED — see the licensing note below. By default the tool DETECTS the project's language (JS/TS vs Python from the working dir) and returns the charts for THAT language, SCOPED and ordered by how well each type fits this data (best first; `order: 'variety'` favors newer and less-common types instead), each tagged with its source language and renderer. Pass `language` ('javascript'|'python') to force it, or `renderer` ('D3'/'PLOTLY'/…) to rank one specific renderer, or renderer '' for the full renderer-agnostic eligibility across ALL renderers (also ranked, by chart type alone, with no renderer/language tag). If the language can't be auto-detected and none is given, the tool asks you to specify one. Needs an account: eligibility IS the engine, so programmatic access to it is licensed. With nothing configured, the first call opens a browser sign-in, waits for it and then answers (a license key in the environment is the alternative for a machine with no browser). Free within a generous hourly allowance; beyond it each call draws usage credits. The reply carries a text block and a structured table: one row per chart type with its rank, name, preview flag, fit verdict, description, language and renderer. Rows flagged alsoWorthALook are a few picks from below the top fits, drawn so an offer can include something different; the fit order itself never changes. A type that fits only once the rows are totalled (raw rows where the chart wants one per category) is listed under its own heading, once per grain: each row carries the sentence that says how the rows are totalled first and that grain's projection key. | Somente leitura |
| generate_chart | Generate ready-to-render chart code for a dataset via the BIC backend: the data shape is profiled locally, the backend picks a suitable chart type (or honors chart_type), and returns code that has passed the backend's eligibility gates and quality checks. Needs a trial or paid account: with nothing configured, the first call opens a browser sign-in, waits for it and then finishes the chart (a license key in the environment or ~/.bic/credentials.json is the alternative for a machine with no browser). The returned D3 code is a portable render(container, data, options) function meant to be MERGED into your own app; an integration contract describes exactly how to call it. A standalone HTML preview and file output are optional. The arguments chart_style, level_of_detail and culture are the person's choices, and the guide's 'settings' topic lists every choice a person can make with its options. | Ação |
| preview_request | Shows exactly what a chart generation would send to the BIC backend for these arguments - the measured shape of your data (column names, types, counts, ranges), the settings, and whether any sample rows travel - with the credentials removed. SENDS NOTHING and needs no license: it is local and free. Takes the same arguments as a generation. It answers 'what data leaves my machine?'; the eligibility list sends a subset of the same shape. | Somente leitura |
| check_request | Checks a chart request against this data before anything is generated. Takes the same arguments as a generation - the chart type and every setting (date grain, limit, overlay, required columns, rows policy, data labels and the rest) - and answers, in the server's own words, each ask this data can't honor and why: a channel the data doesn't have, too little of one for the ask, or a name the catalog doesn't know. When the chart type itself is denied, it also lists up to five chart types that fit this data, best fit first. An OK names the asks it checked. Profiles the data locally and sends that profile, as a generation would; no sample rows travel. NO LLM in the loop and no generation credits are spent, but this is a NETWORK call and it is METERED like the eligibility list: free within a generous hourly allowance, then usage credits per call. Needs an account: with nothing configured, the first call opens a browser sign-in (a license key in the environment is the alternative). The reply carries a text block and a structured result: the verdict (OK or DENY), the asks checked, each finding with its kind and reason, and the alternatives. | Somente leitura |
| check_chart | Verify a generated chart locally before deploying: draws the chart.js that generate_chart wrote, headless, against its data - the rows query_semantic_model saved, a CSV, or the rows it was generated for - through @bicharts/chart-host, and reports in plain words: the marks drawn by kind, anything thrown (with the line), whether it came out blank, anything drawn outside its frame, and whether a click on a mark reaches onSelect with source rows. Takes seconds; local and free (no network, no credentials, nothing sent). Run it after each generate_chart instead of deploying to see whether a chart works, and check at the size the panel will give it: by default it reads minChartWidth and minChartHeight off the app's BicChartPanel around the chart (else the size it was generated for); pass width and height only for another size. A WARNING line is a label cut off at that size even at a narrow font's width; the reply says whether more room fixes it. The app's own legend and frame fit is NOT run in the check, so a label it flags may already be handled in the app. Never edit the generated chart code by hand to clear a finding: regenerate it (generate_chart, with a prompt describing the fix) or report it. It does not judge colors or real font widths. | Somente leitura |
| check_app | Check how the app uses the chart library, before every deploy and after check_chart: reads the app's own source (never the files generate_chart and setup_fabric_app wrote) and reports, each with file, line and the library call to use instead: hand-written selection glue (a toggle, a second-click guard, a remount to clear) where useBicFilter + selects does it; each chart's filter wiring - the page filter its clicks set and the filters its query or component follows (filtered query, highlight only or none) - with a chart filtered by the filter it sets, a treatAs column the model's relationships can't carry to the panel, or to one of its measures (read from the tables each measure's expression reads) (read from the project's schema cache, .schema/models/*/model.sqlite), a total that isn't the sum of the parts the page shows (a rounding measure at the total), a click filter keyed coarser than the marks that set it, a chart carrying write markers whose query drops rows the write form can target, several charts sharing one click filter, a chart no page filter reaches, and a panel whose filtered query it isn't given; a "vs" measure in the app's .dax queries that is never blank (BLANK() - 1 is -1), a card that names a window ("2019 to 2025") over a query with no bound on it, and a query a line over time reads that can drop a quiet period (SUMMARIZECOLUMNS with no COALESCE or ADDMISSINGITEMS), a query whose range is a date written in (DATE ( y, m, d )) where it should come from the data or the person's words; a write that stores a placeholder name ("unknown") when no one is signed in or a time from the browser's clock, a Rayfin entity that takes any name on create or lets any row be updated again (rayfin/data), a name shown (createdBy) its policy doesn't check against the caller's token, a function that reads the caller's email from preferred_username or upn (Rayfin reads only the email claim), a write that resolves before its reload lands (so its button comes back on over the old rows), reloads applied out of order, a list that can't tell loading from empty, a form default read once, a due date with no lower bound, a due date the server refuses by UTC's today (or its own) while the form's min is the reader's date, a read of every row on every open, a panel with no Retry, a write that only a chart pick can aim (no searchable picker), a list for a picked owner filtered on another owner field than the form saves, a sign-in check weaker than the save's, a lookup whose rows feed the page while its loading and failure show only in a dialog, a blank value put into text with String() ("null"), saved rows never reloaded when the page comes back into view, a done-once write that reloads only on success, a dialog list copied into state when it opened, and a dialog that doesn't hold the keyboard; light and dark: no light/dark toggle, the template's theme hook (it flips a reader's pick back), a color written as a literal where a theme token belongs, and a dialog scrim that washes the page in one theme; a card's static text that states an order the reader can change ("highest first"); a page filter read as its first key only (`.value`), where a group pick holds several; row positions read from the DOM; the payload's __rowIdx__ / __geo* columns built by hand; a slider beside a chart that draws its own controls (useBicControls); notes kept but never shown on the marks (annotations); a chart outside a BicChartPanel, a fixed height below the panel's minimum, a fixed card height whose title and subtitle (wrapped at a phone's width) leave its chart under its minimum, a minChartWidth wider than a phone gives a chart (294px) and than the chart type's own minimum, a chart's card narrower than its chart's minimum at any page width from 1024 to 1920px (worked out from the page's grid), a flex-1 container without min-h-0 / min-w-0; two charts setting the same element id; a chart that judges a measure good or bad but was generated with no direction of good; an installed @bicharts/chart-host older than the generated components need (0.6.86); and @bicharts / Rayfin / Fabric visuals packages behind npm's latest. It also draws every chart under src/charts the way check_chart does and reports any that throw, come out blank or don't pass a click to onSelect. Local and free; npm is only asked for versions, and a stack finding is skipped when npm can't be reached. Layout findings are WARNINGS: a static read can't prove a layout. Fix the app's own files; regenerate a chart rather than edit its generated code. | Somente leitura |
| setup_fabric_app | Run once in a Microsoft Fabric App scaffolded from Rayfin's data app template, before the first chart: installs @bicharts/chart-host (at this server's version) and d3, adds src/lib/bic-chart-options.ts (the app's Fabric theme as chart options) and src/components/bic-chart-panel.tsx (a chart box that measures itself and shows the query's loading, error and empty states) and .agents/skills/regiabi-charts/SKILL.md (also written to .claude/skills/, where Claude Code reads it), ignores .bic/, and puts every @microsoft/rayfin-* package on npm's latest, the release `rayfin init` installs (run it before rayfin init; every package.json range it changes is listed, and the reply names the Rayfin version installed). Never overwrites a file; the one template file it edits - a vi.mock that fixes the template's own validate-visual test under ESM - is named in the reply, as is the one line of src/main.tsx it points at src/lib/bic-css-theme.ts (the theme without bundling Vega). With features: ["notes"] and/or ["scenarios"] (once Rayfin's data service is on), it also adds finished notes-on-marks and saved-scenario files - the Rayfin entities, registered in rayfin/data/schema.ts, a hook each, a notes dialog and a scenarios panel - built on chart-host's useBicFilter / useBicControls; write none of that by hand. Replies with a worked example that renders a generated chart from a live query. | Ação |
| query_semantic_model | In a Microsoft Fabric App built on Rayfin's data app template: runs one chart's DAX query through the project's own tooling - its semantic model's Rayfin connector (rayfin/rayfin.yml), or on the template's older layout its `fabric-app-data` CLI - renames the `Table[Column]` and `[Measure]` headers to plain names (the names the chart.component.tsx that generate_chart writes will match on live rows), saves EVERY row as CSV, reads each column's role, format and description from the model, and profiles the result. Replaces the query, rename, save and profile steps with one call, and returns the arguments to pass to list_eligible_charts and generate_chart. Write the query at the chart's grain (one row per country for a country map). Local: the data goes only where the project's own tooling already sends it, and nothing reaches the chart server. | Ação |
| suggest_charts | Which charts suit this data? Answers 'what are good chart types for this dataset / model', 'what can I chart here', 'recommend some charts' for a semantic model in a Microsoft Fabric App built on Rayfin's data app template, in ONE call, from the model's real rows: reads its tables, columns, measures and relationships through the project's own tooling (its Rayfin connector, or the older layout's `fabric-app-data` CLI), finds its natural views (measures by place, flows between places, measures over time, measures by category), queries each at its grain, keeps the measures that vary there, and asks the server's eligibility engine what fits each view. Replies view by view with the real counts (rows, places, periods, categories) and the chart types that fit, and saves each view's rows and DAX under .bic/data so generate_chart can build any of them next. Pass `views` to ask about your own groupings. Answer the person from this reply rather than from general knowledge. One eligibility call per view: metered like list_eligible_charts (free within an hourly allowance, usage credits beyond it) and needs the same license. For one table you already hold, use list_eligible_charts. | Ação |
Configuração
BIC_LICENSE_KEYSecretoOptional. The license key for that account, with BIC_LICENSEE, instead of signing in. Authoring needs a trial or paid account; running a generated chart needs nothing.
BIC_SECRET_KEYSecretoOptional secret key, if your account uses one.
BIC_LICENSEEOptional. Leave it unset and the first chart call opens your browser to sign in (or create a free account). Set it with BIC_LICENSE_KEY to use a license key instead, for machines with no browser.
BIC_MCP_QUERY_ROW_CAPOptional. The most rows a semantic-model query keeps (default 250000, at most 1000000, Power BI's own ceiling). Raising it costs time and memory on every call that reads the rows.
| Nome | Descrição | Tipo |
|---|---|---|
| BIC_LICENSE_KEY | Optional. The license key for that account, with BIC_LICENSEE, instead of signing in. Authoring needs a trial or paid account; running a generated chart needs nothing. | Secreto |
| BIC_SECRET_KEY | Optional secret key, if your account uses one. | Secreto |
| BIC_LICENSEE | Optional. Leave it unset and the first chart call opens your browser to sign in (or create a free account). Set it with BIC_LICENSE_KEY to use a license key instead, for machines with no browser. | |
| BIC_MCP_QUERY_ROW_CAP | Optional. The most rows a semantic-model query keeps (default 250000, at most 1000000, Power BI's own ceiling). Raising it costs time and memory on every call that reads the rows. |
Verificações automatizadas
Executado em 16 de nov. de 2026Relatório completo →Passou em nossas verificações automatizadas. Isso não é uma auditoria de segurança: leia o código e dê ao servidor o acesso mais restrito de que ele precisa. Como as verificações funcionam
- Repositório de origem vinculado e acessívelcodexguy/regiabi-plugins is public and reachablegithub.com/codexguy/regiabi-plugins ↗Passou
- O pacote indica este repositório como sua origem@bicharts/chart-mcp names codexguy/regiabi-plugins as sourcenpmjs.com/package/@bicharts/chart-mcp ↗Passou
- Proveniência da build (atestação Sigstore)No build attestation published for this releaseNão verificado
- Licença de código aberto (OSI)MITspdx.org/licenses/MIT.html ↗Passou
- Commit ou release no último anoLast commit or release 2026-11-16github.com/codexguy/regiabi-plugins ↗Passou
- OpenSSF ScorecardNão verificado
- Nome do pacote não é próximo a um pacote popularNo popular package one edit away from @bicharts/chart-mcpPassou
- Nenhum aviso crítico no pacote ou em suas dependênciasthe package checked; no critical advisoryosv.dev ↗Passou
- Sem instruções ocultas para o modelo11 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPassou
- Ferramentas destrutivas estão rotuladasNo tool named like delete, drop or execPassou
- O endpoint remoto responde ao handshake do MCPHTTPS endpoint answered 401 (sign-in required)Passou
README
Ver no GitHubRegiaBI: an MCP server and agent plugin
Make Generative AI for Data Apps and Maps Better.
AI Data Components for Power BI, Excel, Fabric Apps and the web: complete apps first, such as a what-if projection with its controls inside the chart and a table a reader works with, then maps such as a bivariate map with its two-way key, and about 90 everyday chart types, with selection and cross-filtering already wired. The code is yours: you pay to author a chart, never to run it.
This repository packages the RegiaBI chart MCP server (com.regiabi/chart-mcp, published on npm as
@bicharts/chart-mcp) and its agent skill as a one-command
plugin for Claude Code, GitHub Copilot CLI, Codex and Gemini CLI. It holds the plugin manifests, the pinned server
command and the skill. The server itself is the npm package. The Claude Code plugin connects to the same server
hosted by RegiaBI instead of running it on your machine (see Claude Code).
What it does
Give your coding agent a table (a CSV, a dataframe, or a query result from a semantic model) and it gets back working, interactive chart code that fits that data:
- It profiles your data locally. Row counts, cardinalities, measures versus dimensions, dates, places. No data leaves your machine for this step.
- It ranks about 90 chart types by what the data can honestly show, using a server-side eligibility engine rather than a guess, so a map is only offered when there are places to map and a sankey only when there are flows.
- It returns verified source you own: D3 for JavaScript and TypeScript projects, Plotly or matplotlib for Python. The code has already passed render checks. It needs no license, no account and no connection to us to run, deploy or ship, for any number of viewers.
The tools:
| Tool | What it's for |
|---|---|
assess_data_shape |
Profiles a table locally. Free, and needs no account. |
list_eligible_charts |
The authoritative list of chart types that fit this data, ranked for your project's language. |
suggest_charts |
For a Microsoft Fabric App over a semantic model: finds the model's natural views and what fits each, in one call. |
generate_chart |
Writes the chart: code, data and wiring for @bicharts/chart-host (open source), into your project. |
Install
Claude Code
/plugin marketplace add codexguy/regiabi-plugins
/plugin install regiabi-charts@regiabi
The Claude Code plugin connects to RegiaBI's hosted server at https://bizintelligencechampions.com/mcp. Claude
Code signs you in through your browser the first time a tool needs your account (run /mcp if it doesn't ask).
The hosted server profiles each table in memory and drops its rows; it can't read or write your files, so it
returns each chart's code in the reply, and your agent writes it into your project.
Building a Fabric App, or want the charts written straight to disk? setup_fabric_app, suggest_charts,
query_semantic_model and generate_chart's out_dir need the server running on your machine. Add it alongside
the plugin:
claude mcp add bic-chart-local -- npx -y @bicharts/chart-mcp@0.6.117
GitHub Copilot CLI
copilot plugin marketplace add codexguy/regiabi-plugins
copilot plugin install regiabi-charts@regiabi
Codex
codex plugin marketplace add codexguy/regiabi-plugins
Then install RegiaBI apps from the Plugins Directory.
Gemini CLI
gemini extensions install https://github.com/codexguy/regiabi-plugins
Any other MCP client
VS Code, Cursor, Claude Desktop and any other MCP client can run the server directly:
{
"mcpServers": {
"bic-chart": {
"command": "npx",
"args": ["-y", "@bicharts/chart-mcp"]
}
}
}
Configure
Nothing, usually. Writing a chart needs a RegiaBI account; running a chart you've already generated needs nothing.
Sign in when it asks. The first time your agent calls a tool that needs an account, the server opens your
browser at bizintelligencechampions.com. Sign in, or create a free account (it comes with a free trial), and click
Allow. The call your agent made then finishes by itself. The server keeps the sign-in in ~/.bic/oauth.json
and renews it on its own, and you can sign a device out at any time from your account page.
Or use a license key (a machine with no browser, CI, a container). Leave sign-in alone and give the server your account's credentials instead, in one of two ways:
-
As environment variables on the server:
BIC_LICENSEEandBIC_LICENSE_KEY, plusBIC_SECRET_KEYif your account uses one. -
A credentials file, so no secret ever sits in a project's committed config. Put this in
~/.bic/credentials.json(or pointBIC_CREDENTIALS_FILEat another path):{ "licensee": "...", "licenseKey": "..." }
A key, when one is set, always wins over a sign-in. A key applies to the server on your machine; the hosted server behind the Claude Code plugin always uses the browser sign-in.
Use
Ask your agent for the chart you want, in plain words, in the project you want it in. For example:
Assess the shape of ./sales.csv, tell me which charts fit it, then generate the best one into ./charts.
The agent profiles the file, asks the server which chart types fit, and writes the chart's code and data into
./charts, ready to import. The skill this plugin installs walks the agent through the rest: wiring
cross-filtering between charts, sizing and theming are the host library's job, so the agent doesn't write them.
Building a Microsoft Fabric App? Scaffold it from Rayfin's data app template, then ask your agent which charts
suit your semantic model. suggest_charts answers from the model's own numbers.
What it runs, sends and fetches
- Signing in opens your browser at
bizintelligencechampions.comonce; the server then keeps an access token and a refresh token in~/.bic/oauth.json(readable only by you) and sends the access token with each call to the service. - It runs one local process:
npx -y @bicharts/chart-mcp@<version>, the exact version the plugin pins. npm downloads that package from the public npm registry the first time. The Claude Code plugin runs nothing on your machine: it connects tohttps://bizintelligencechampions.com/mcp, which receives the tables your agent sends it, profiles them in memory and stores no rows. assess_data_shapesends nothing. It profiles your data on your machine.list_eligible_charts,suggest_chartsandgenerate_chartcall the RegiaBI service atbizintelligencechampions.comwith your account's credentials and a profile of your table: column names, types, counts and summary statistics. By default no rows are sent; aprivacy_levelargument can send less (names only) or more (obfuscated sample rows).suggest_chartsqueries your semantic model through your Fabric App project's ownfabric-app-dataCLI, signed in as you, and sends the service the same kind of profile.- It writes the generated chart code and its data into the folder you ask for, and nowhere else.
- Telemetry: one row when
generate_charthands code over (the call's duration, the row count, the language and the server's build) and one when a generation fails after the service answered. No data, and no usage counter: the service counts calls from the requests it receives. SetBIC_MCP_TELEMETRY=0in the server's environment to turn both rows off. - Signing in sends this computer's name (its hostname), so the sign-in shows up on your account page and you can sign that machine out on its own.
check_appasks the npm registry for the latest versions of the packages your app uses (check_npm: falseskips it), andpreview.htmlloads d3 and mermaid from cdn.jsdelivr.net when you open it (it's only written when you passpreview_html: true).
Learn more
- RegiaBI for developers: docs, examples and live demos
@bicharts/chart-mcpon npm: every tool's parameters and results@bicharts/chart-host: the open-source library that runs the charts- The official MCP Registry listing
Support and terms
- Support: a paid RegiaBI subscription includes direct support from
the people who build the engine (setup, sign-in, a call that fails, a chart that didn't come out right), and a
license you already hold for one of our Power BI or Excel visuals counts. Quote the
correlationIdfrom the result. - The server and the service it calls are covered by the RegiaBI Programmatic Access Terms and the privacy policy. The server's own license ships in its npm package.
- The files in this repository (the plugin manifests, the README and the skill) are under the MIT license in LICENSE. They contain no server source.
Perguntas sobre o MCP RegiaBI
Como adiciono o MCP RegiaBI ao Claude Code?
Execute claude mcp add --env 'BIC_LICENSE_KEY=<YOUR_BIC_LICENSE_KEY>' --env 'BIC_SECRET_KEY=<YOUR_BIC_SECRET_KEY>' regiabi-plugins -- npx -y @bicharts/chart-mcp no seu terminal. Adicione --scope user para torná-lo disponível em todos os projetos.
Como adiciono o MCP RegiaBI ao Cursor?
Abra ~/.cursor/mcp.json e adicione o servidor em mcpServers, usando a configuração do Cursor mostrada na seção de instalação acima.
Quais ferramentas o MCP RegiaBI oferece?
Ele expõe 11 ferramentas, incluindo assess_data_shape, get_guide, list_eligible_charts, generate_chart, preview_request.
Meus dados saem da minha máquina durante o profiling?
Não, a etapa de profiling acontece localmente na sua máquina e nenhum dado é enviado durante esse processo.
Quais linguagens de programação são suportadas para o código gerado?
O servidor fornece D3 para projetos JavaScript e TypeScript, e Plotly ou matplotlib para projetos Python.
Como faço para me autenticar no servidor?
Você pode fazer login via um fluxo OAuth no navegador ou usar uma chave de licença fornecida por meio de variáveis de ambiente ou um arquivo de credenciais.