Normality Test Engine MCP for AI. Validate your data distribution before running any statistical model.

Q: How does testnormality ensure accuracy when calculating statistics?

It uses the specialized simple-statistics library, which computes coefficients like Skewness and Kurtosis exactly. This process prevents mathematical guesswork that you might get from generic LLM math functions.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Normality Test Engine runs Jarque-Bera tests and calculates Skewness/Kurtosis coefficients locally. It validates if your data set follows a normal distribution, providing exact p-values and clear pass/fail verdicts for statistical analysis.

This is essential pre-screening before running parametric tests like t-tests or ANOVA.

What your AI can do

Test normality

Runs an exact Jarque-Bera normality test on numeric data, guaranteeing no math hallucinations from the LLM.

Check Data Distribution

The server runs an exact Jarque-Bera test to determine if numeric data is normally distributed.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Normality Test Engine MCP Server: 1 Tool for Statistical Validation

Use the single tool here to run deterministic Jarque-Bera tests, validating if your numeric data is normally distributed without relying on LLM math.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using Normality Test Engine on Vinkius

Test Normality

Runs an exact Jarque-Bera normality test on numeric data, guaranteeing no math hallucinations from the LLM.

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Normality Test Engine integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "normality-test-engine": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Normality Test Engine tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"normality-test-engine": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with Normality Test Engine, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by simple-statistics. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 1 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Statistical analysis shouldn't feel like guesswork.

Today, checking data assumptions is a manual headache. You gather your raw numbers, open three different statistical packages, and run separate checks for Skewness, Kurtosis, and the Jarque-Bera test. Then you have to interpret dozens of p-values just to confirm if you can even start modeling.

With this MCP server, you hand over your dataset once. The `test_normality` tool handles all that math locally and spits out a single, clear verdict—a definitive pass or fail on normality. You get the exact coefficients *and* the interpretation in one shot.

Normality Test Engine MCP Server: Get verifiable statistical proof.

You no longer have to trust that an LLM's internal math functions will handle complex, sensitive statistics correctly. You don't need to copy-paste data into external sites just to get a basic test statistic.

This engine runs the full Jarque-Bera analysis deterministically and locally. It gives you the statistical certainty needed for published research or mission-critical model deployment—no compromises.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

Listen up. Before you run any serious parametric test—like a t-test or ANOVA—you gotta confirm your data is actually normally distributed. You can't just eyeball that; an LLM doesn't read distributions the way a statistician does, and its guess is usually wrong.

The test_normality tool runs an exact Jarque-Bera normality test on numeric data. It guarantees your AI client gets real math, not some hallucination from the model itself. This isn't just guesswork; it’s rigorous statistical pre-screening you need before your analysis makes sense.

The server checks data distribution by computing Skewness and Kurtosis coefficients locally. You input a set of numbers, and the agent spits out definitive math that won't fail on you when you need it most. It gives you the whole picture: whether your dataset follows a normal curve or not.

When you run test_normality, your AI client gets much more than just a simple yes/no. You get an exact test statistic, and crucially, the p-value for the Jarque-Bera test. This gives you a clear pass/fail verdict on normality. It’s essential because running those parametric tests—like linear regression or ANOVA—on non-normal data invalidates your results, plain and simple.

The process is straightforward: feed it numeric data. The server calculates the exact Skewness and Kurtosis coefficients for that set. You'll also get the mean and standard deviation values you need to document your work. It’s a complete statistical snapshot.

If the data isn't normal, the test tells you exactly how far off it is, giving you the necessary information to decide if you need to transform the data or switch to non-parametric alternatives. You don't have to guess what kind of analysis you can actually run; this tool narrows that down for you.

You rely on the ability to check the distribution first. The server handles all the complex calculations—the Jarque-Bera test, Skewness, and Kurtosis—and delivers a single, actionable verdict straight up. It’s built to provide reliable results right in your workflow, letting you skip the manual data checks and get straight to conclusions.

Built · Hosted · Managed by Vinkius Normality Test Engine - Validate Data Distribution

Server ID 019e38eb-8553-73df-affe-f5db91905c75

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

Here's how it actually works

The bottom line is you get verifiable statistical proof that your data meets the assumptions required for advanced mathematical testing.

Feed the engine a set of numeric residuals or raw data arrays.

The test_normality tool executes the Jarque-Bera test and calculates statistical coefficients locally.

You receive a definitive p-value, Skewness, Kurtosis values, and an interpretation stating whether the data passes the normality check.

What Changes When You Connect

Get a definitive pass/fail verdict instantly. The test_normality tool returns the Jarque-Bera p-value and explicitly states if you can reject the normality hypothesis.

Avoid mathematical errors in downstream models. By checking Skewness and Kurtosis first, you ensure your data meets the assumptions required for t-tests or ANOVA.

Keep your research private. All statistical computations happen locally on your machine; no raw data leaves your environment.

Get more than just a yes/no answer. The engine provides the exact Mean, Std Dev, Skewness, and Kurtosis coefficients needed for deep reporting.

Stop guessing about distribution. You get verifiable statistics—the exact test statistic and p-value—that you can trust in published work.

See it in action

01 01

Checking Model Residuals

You just ran a linear regression, but you don't know if the residuals are normal enough for your confidence intervals. You feed the residuals array into test_normality. If the p-value is high, you proceed; otherwise, you switch to non-parametric methods.

02 02

Prepping Sensor Data

A sensor generates stream data that needs statistical validation. Instead of running a full analysis and risking bias, your agent uses test_normality first. If the data shows high skewness, it flags the need for data transformation before modeling.

03 03

Validating Financial Metrics

Before calculating confidence intervals on revenue or profit, you must confirm normality. You run test_normality on the 'Revenue' column. A passing test (high p-value) confirms that your subsequent financial metrics are valid.

04 04

Comparing Groups

You have two groups of experimental data and need to compare them using ANOVA, but you can't be sure they come from normal distributions. You run test_normality on each group dataset separately to verify assumptions before testing.

The honest tradeoffs

Relying on LLM guesses

Anti-pattern

Asking an agent, 'Is this data normally distributed?' and accepting a vague answer. The LLM might hallucinate the p-value or just give a generic warning.

The Fix

Use test_normality to get the precise Jarque-Bera test statistic and p-value locally. This gives you verifiable, deterministic math.

Skipping pre-checks

Anti-pattern

Jumping straight into a t-test or linear regression on raw data without checking assumptions. Your results are mathematically invalid from the start.

The Fix

Always run test_normality first. It provides the necessary validation step to ensure your parametric tests are even applicable.

Assuming normality

Anti-pattern

Believing that because a dataset looks bell-curved on a chart, it is statistically normal. Visual confirmation isn't enough.

The Fix

Use test_normality to get the quantitative proof: Skewness and Kurtosis coefficients. These numbers tell you if the distribution actually meets the criteria.

When It Fits, When It Doesn't

Use this engine if your workflow requires statistical rigor—specifically, if you plan on performing parametric tests like ANOVA or linear regression. You need to confirm that your data residuals are normally distributed before those calculations yield reliable results.

Don't use it if you just need basic descriptive statistics (Mean, Std Dev). Those values come from standard libraries anyway. Also, don't use this if your dataset is already known to be non-parametric; in that case, skip the test and select an appropriate alternative statistical method instead. If you are unsure, run test_normality—it’s a necessary preliminary screening step.

Questions you might have

How does Normality Test Engine handle data privacy? +

The tests run entirely on your local machine, not in the cloud. Your raw research data never leaves your environment. This is key for sensitive datasets.

Can I use test_normality with non-numeric data? +

No. The tool requires numeric input to calculate statistical coefficients like Skewness and Kurtosis. If your data isn't quantifiable numbers, you need a different analysis approach.

Is the result from test_normality definitive proof of normality? +

It provides a highly reliable, statistically calculated verdict based on the Jarque-Bera test. However, always remember it's a screening step; deep validation requires domain expertise.

What is the difference between this and standard statistical software? +

This MCP integrates that functionality into your AI workflow. You get the precision of specialized software (like simple-statistics) without leaving your chat or IDE.

If my dataset contains null or missing values, how does the `test_normality` tool handle it? +

The tool requires a clean array of finite numbers. If you include NaNs (Not a Number) or infinite values, the test will fail and return an explicit error code indicating invalid input data. You must pre-clean your data.

Can I use `test_normality` with live, streaming sensor feeds? +

No. The server is designed for static analysis of compiled datasets. You must collect the stream data into a complete batch array before passing it to the tool for testing.

Does `test_normality` check for multivariate normality? +

No, this engine performs a univariate Jarque-Bera test. It analyzes one variable's distribution at a time; you need to run the tool separately on each dimension in your dataset.

How does `test_normality` ensure accuracy when calculating statistics? +

It uses the specialized simple-statistics library, which computes coefficients like Skewness and Kurtosis exactly. This process prevents mathematical guesswork that you might get from generic LLM math functions.

Is this the Shapiro-Wilk test? +

This engine implements the Jarque-Bera normality test, which uses Skewness and Kurtosis. It is highly effective for medium-to-large samples and avoids the Shapiro-Wilk implementation gaps in JavaScript.

How many data points do I need? +

The Jarque-Bera test works best with 30 or more samples. For very small samples (n < 20), consider using visual QQ-plot analysis as a complement.

What does a 'not normal' result mean for my analysis? +

If your data is not normally distributed, parametric tests like t-tests and ANOVA may be unreliable. Consider using non-parametric alternatives like Spearman correlation or Mann-Whitney U tests.

Connect to your AI in seconds.

Test normality

Normality Test Engine MCP Server: 1 Tool for Statistical Validation

Make your AI actually useful.

Test Normality

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Statistical analysis shouldn't feel like guesswork.

Normality Test Engine MCP Server: Get verifiable statistical proof.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Checking Model Residuals

Prepping Sensor Data

Validating Financial Metrics

Comparing Groups

The honest tradeoffs

Relying on LLM guesses

Skipping pre-checks

Assuming normality

When It Fits, When It Doesn't

Questions you might have