Disco
The Disco server enables automated discovery of statistically validated patterns in tabular data through an MCP interface, covering everything from account creation to running analyses and retrieving results.
Account & Authentication
Sign up / verify: Create a new account via email and 6-digit verification code — no password or credit card required.
Log in / verify: Retrieve a new API key for an existing account via email verification.
Check account status: View your current plan, available credits, and payment method status.
Pricing, Plans & Payments
List plans: Browse available subscription tiers (Free, Researcher, Team) with pricing and credit allowances.
Subscribe: Switch to or enroll in a plan.
Add payment method: Attach a Stripe-tokenized payment method.
Purchase credits: Buy credit packs ($10/pack, 100 credits each) for private analyses.
Data Analysis Workflow
Estimate costs: Before running, get a cost estimate (credits, duration, sufficiency) for a given file size, column count, depth, and visibility setting.
Upload data: Upload datasets via URL, local file path, or base64-encoded content — supports CSV, TSV, Excel, JSON, Parquet, ARFF, and Feather (up to 5 GB).
Run analysis: Launch a discovery pipeline on uploaded data to find feature interactions, subgroup effects, and conditional relationships — with FDR-corrected p-values and optional academic literature novelty checks. Choose between public runs (free, but results are published) or private runs (credit cost, results kept confidential). Optionally leverage LLMs for smarter pre-processing, richer summaries, and more accurate novelty assessments.
Check status: Poll a running analysis (typically 3–15 minutes) for its status, queue position, active pipeline step, and time estimates.
Get results: Retrieve discovered patterns (conditions, effect sizes, p-values, novelty classifications, citations), feature importances, summary insights, and interactive dashboard links.
Provides integration with Jupyter notebooks through the discovery-engine-api[jupyter] package, enabling interactive pattern discovery and analysis within notebook environments.
Provides integration with pandas for data analysis, allowing users to prepare tabular data for pattern discovery while excluding pandas-based operations like summary statistics, visualization, and filtering from the discovery process.
Provides integration with PyPI for installing the discovery-engine-api Python package, enabling users to access the Disco pattern discovery service through the Python SDK.
Provides integration with Python through the discovery-engine-api SDK, enabling programmatic access to Disco's pattern discovery capabilities including data analysis, account management, and result retrieval.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
Disco
Find novel, statistically validated patterns in tabular data — feature interactions, subgroup effects, and conditional relationships that humans and agents miss.
Made by Leap Laboratories.
What it actually does
Most data analysis starts with a question. Disco starts with the data.
Without biases or assumptions, it finds combinations of feature conditions that significantly shift your target column — things like "patients aged 45–65 with low HDL and high CRP have 3× the readmission rate" — without you needing to hypothesise that interaction first.
Each pattern is:
Validated on a hold-out set — increases the chance of generalisation
FDR-corrected — p-values included, adjusted for multiple testing
Checked against academic literature — to help you understand what you've found, and identify if it is novel.
The output is structured: conditions, effect sizes, p-values, citations, and a novelty classification for every pattern found.
Use it when: "which variables are most important with respect to X", "are there patterns we're missing?", "I don't know where to start with this data", "I need to understand how A and B affect C".
Not for: summary statistics, visualisation, filtering, SQL queries — use pandas for those
Related MCP server: Discovery Engine MCP Server
Quickstart
pip install discovery-engine-apiGet an API key:
# Step 1: request verification code (no password, no card)
curl -X POST https://disco.leap-labs.com/api/signup \
-H "Content-Type: application/json" \
-d '{"email": "you@example.com"}'
# Step 2: submit code from email → get key
curl -X POST https://disco.leap-labs.com/api/signup/verify \
-H "Content-Type: application/json" \
-d '{"email": "you@example.com", "code": "123456"}'
# → {"key": "disco_...", "credits": 10, "tier": "free_tier"}Or create a key at disco.leap-labs.com/developers.
Run your first analysis:
from discovery import Engine
engine = Engine(api_key="disco_...")
result = await engine.discover(
file="data.csv",
target_column="outcome",
)
for pattern in result.patterns:
if pattern.p_value < 0.05 and pattern.novelty_type == "novel":
print(f"{pattern.description} (p={pattern.p_value:.4f})")
print(f"Explore: {result.report_url}")Runs take a few minutes. discover() polls automatically and logs progress — queue position, estimated wait, current pipeline step, and ETA. For background runs, see Running asynchronously.
→ Full Python SDK reference · Example notebook
What you get back
Each Pattern in result.patterns looks like this (real output from a crop yield dataset):
Pattern(
description="When humidity is between 72–89% AND wind speed is below 12 km/h, "
"crop yield increases by 34% above the dataset average",
conditions=[
{"type": "continuous", "feature": "humidity_pct",
"min_value": 72.0, "max_value": 89.0},
{"type": "continuous", "feature": "wind_speed_kmh",
"min_value": 0.0, "max_value": 12.0},
],
p_value=0.003, # FDR-corrected
novelty_type="novel",
novelty_explanation="Published studies examine humidity and wind speed as independent "
"predictors, but this interaction effect — where low wind amplifies "
"the benefit of high humidity within a specific range — has not been "
"reported in the literature.",
citations=[
{"title": "Effects of relative humidity on cereal crop productivity",
"authors": ["Zhang, L.", "Wang, H."], "year": "2021",
"journal": "Journal of Agricultural Science"},
],
target_change_direction="max",
abs_target_change=0.34, # 34% increase
support_count=847, # rows matching this pattern
support_percentage=16.9,
)Key things to notice:
Patterns are combinations of conditions — humidity AND wind speed together, not just "more humidity is better"
Specific thresholds — 72–89%, not a vague correlation
Novel vs confirmatory — every pattern is classified; confirmatory ones validate known science, novel ones are what you came for
Citations — shows what IS known, so you can see what's genuinely new
report_urllinks to an interactive web report with all patterns visualised
The result.summary gives an LLM-generated narrative overview:
result.summary.overview
# "Disco identified 14 statistically significant patterns. 5 are novel.
# The strongest driver is a previously unreported interaction between humidity
# and wind speed at specific thresholds."
result.summary.key_insights
# ["Humidity × low wind speed at 72–89% humidity produces a 34% yield increase — novel.",
# "Soil nitrogen above 45 mg/kg shows diminishing returns when phosphorus is below 12 mg/kg.",
# ...]How it works
Disco is a pipeline, not prompt engineering over data. It:
Trains machine learning models on a subset of your data
Uses interpretability techniques to extract learned patterns
Validates every pattern on the held-out data with FDR correction (Benjamini-Hochberg)
Checks surviving patterns against academic literature via semantic search
You cannot replicate this by writing pandas code or asking an LLM to look at a CSV. It finds structure that hypothesis-driven analysis misses because it doesn't start with hypotheses.
Preparing your data
Before running, exclude columns that would produce meaningless findings. Disco finds statistically real patterns — but if the input includes columns that are definitionally related to the target, the patterns will be tautological.
Exclude:
Identifiers — row IDs, UUIDs, patient IDs, sample codes
Data leakage — the target renamed or reformatted (e.g.,
diagnosis_textwhen the target isdiagnosis_code)Tautological columns — alternative encodings of the same construct as the target. If target is
serious, thenserious_outcome,not_serious,deathare all part of the same classification. If target isprofit, thenrevenueandcosttogether compose it. If target is a survey index, the sub-items are tautological.
Full guidance with examples: SKILL.md
Parameters
await engine.discover(
file="data.csv", # path, Path, or pd.DataFrame
target_column="outcome", # column to predict/explain
analysis_depth=2, # 2=default, higher=deeper analysis, lower = faster and cheaper
visibility="public", # "public" (always free, data and report is published) or "private" (costs credits)
column_descriptions={ # improves pattern explanations and literature context
"bmi": "Body mass index",
"hdl": "HDL cholesterol in mg/dL",
},
excluded_columns=["id", "timestamp"], # see "Preparing your data" above
use_llms=False, # Defaults to False. If True, runs are slower and more expensive, but you get smarter pre-processing, summary page, literature context and novelty assessment. Public runs always use LLMs.
title="My dataset",
description="...", # improves pattern explanations and literature context
)Public runs are free but results are published. Set
visibility="private"for private data — this costs credits.
Running asynchronously
Runs take a few minutes. For agent workflows or scripts that do other work in parallel:
# Submit without waiting
run = await engine.run_async(file="data.csv", target_column="outcome", wait=False)
print(f"Submitted {run.run_id}, continuing...")
# ... do other things ...
result = await engine.wait_for_completion(run.run_id, timeout=1800)For synchronous scripts and Jupyter notebooks:
result = engine.run(file="data.csv", target_column="outcome", wait=True)
# or: pip install discovery-engine-api[jupyter] for notebook compatibilityMCP server
Disco is available as an MCP server — no local install required.
{
"mcpServers": {
"discovery-engine": {
"url": "https://disco.leap-labs.com/mcp",
"env": { "DISCOVERY_API_KEY": "disco_..." }
}
}
}Tools: discovery_list_plans, discovery_estimate, discovery_upload, discovery_analyze, discovery_status, discovery_get_results, discovery_account, discovery_signup, discovery_signup_verify, discovery_login, discovery_login_verify, discovery_add_payment_method, discovery_subscribe, discovery_purchase_credits.
Pricing
Cost | |
Public runs | Free — results and data are published |
Private runs | Credits vary by file size and configuration — use |
Free tier | 10 credits/month, no card required |
Researcher | $49/month — 500 credits |
Team | $199/month — 2000 credits |
Credits | $0.10 per credit |
Estimate before running:
estimate = await engine.estimate(file_size_mb=10.5, num_columns=25, analysis_depth=2, visibility="private")
# estimate["cost"]["credits"] → 55
# estimate["account"]["sufficient"] → True/FalseAccount management is fully programmatic — attach payment methods, subscribe to plans, and purchase credits via the SDK or REST API. See Python SDK reference or SKILL.md.
Expected data format
Disco expects a flat table — columns for features, rows for samples.
| patient_id | age | bmi | smoker | outcome |
|------------|-----|------|--------|---------|
| 001 | 52 | 28.3 | yes | 1 |
| 002 | 34 | 22.1 | no | 0 |
| ... | ... | ... | ... | ... |One row per observation — a patient, a sample, a transaction, a measurement, etc.
One column per feature — numeric, categorical, datetime, or free text are all fine
One target column — the outcome you want to understand. Must have at least 2 distinct values.
Missing values are OK — Disco handles them automatically. Don't drop rows or impute beforehand.
No pivoting needed — if your data is already in a flat table, it's ready to go
Supported formats: CSV, TSV, Excel (.xlsx), JSON, Parquet, ARFF, Feather. Max 5 GB.
Not supported: images, raw text documents, nested/hierarchical JSON, multi-sheet Excel (use the first sheet or export to CSV)
Compared to other tools
Goal | Tool |
Summary statistics, data quality | ydata-profiling, sweetviz |
Predictive model | AutoML (auto-sklearn, TPOT, H2O) |
Quick correlations | pandas, seaborn |
Answer a specific question about data | ChatGPT, Claude |
Find what you don't know to look for | Disco |
Disco isn't a replacement for EDA or AutoML — it finds the patterns those tools miss. We tested 18 data analysis tools on a dataset with known ground-truth patterns. Most confidently reported wrong results. Disco was the only one that found every pattern.
Links
Available Tools
14 toolsdiscovery_accountARead-onlyInspect
Check your Disco account status.
Returns current plan, available credits (subscription + purchased), and
payment method status. Use this to verify you have sufficient credits
before running a private analysis.
Args:
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: api_key. Returns: result
discovery_add_payment_methodAIdempotentInspect
Attach a Stripe payment method to your Disco account.
The payment method must be tokenized via Stripe's API first — card details
never touch Disco's servers. Required before purchasing credits
or subscribing to a paid plan.
To tokenize a card, call Stripe's API directly:
POST https://api.stripe.com/v1/payment_methods
with the stripe_publishable_key from your account info.
Args:
payment_method_id: Stripe payment method ID (pm_...) from Stripe's API.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: payment_method_id (required), api_key. Returns: result
discovery_analyzeADestructiveInspect
Run Disco on tabular data to find novel, statistically validated patterns.
This is NOT another data analyst — it's a discovery pipeline that systematically
searches for feature interactions, subgroup effects, and conditional relationships
nobody thought to look for, then validates each on hold-out data with FDR-corrected
p-values and checks novelty against academic literature.
This is a long-running operation. Returns a run_id immediately.
Use discovery_status to poll and discovery_get_results to fetch completed results.
Use this when you need to go beyond answering questions about data and start
finding things nobody thought to ask. Do NOT use this for summary statistics,
visualization, or SQL queries.
Public runs are free but results are published. Private runs cost credits.
Call discovery_estimate first to check cost. Private report URLs require
sign-in — tell the user to sign in at the dashboard with the same email
address used to create the account (email code, no password needed).
Call discovery_upload first to upload your file, then pass the returned file_ref here.
Args:
target_column: The column to analyze — what drives it, beyond what's obvious.
file_ref: The file reference returned by discovery_upload.
analysis_depth: Search depth (1=fast, higher=deeper). Default 1.
visibility: "public" (free) or "private" (costs credits). Default "public".
title: Optional title for the analysis.
description: Optional description of the dataset.
excluded_columns: Optional JSON array of column names to exclude from analysis.
column_descriptions: Optional JSON object mapping column names to descriptions. Significantly improves pattern explanations — always provide if column names are non-obvious (e.g. {"col_7": "patient age", "feat_a": "blood pressure"}).
author: Optional author name for the report.
source_url: Optional source URL for the dataset.
use_llms: Slower and more expensive, but you get smarter pre-processing, summary page, literature context and pattern novelty assessment. Only applies to private runs — public runs always use LLMs. Default false.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: target_column (required), file_ref, analysis_depth, visibility, +8 more. Returns: result
discovery_estimateARead-onlyInspect
Estimate cost, time, and credit requirements before running an analysis.
Returns credit cost, estimated duration in seconds, whether you have
sufficient credits, and whether a free public alternative exists. Always call
this before discovery_analyze for private runs.
Args:
file_size_mb: Size of the dataset in megabytes.
num_columns: Number of columns in the dataset.
num_rows: Number of rows (optional, improves time estimate).
analysis_depth: Search depth (1=fast, higher=deeper). Default 1.
visibility: "public" (free, results published) or "private" (costs credits).
use_llms: Slower and more expensive, but you get smarter pre-processing, summary page, literature context and pattern novelty assessment. Only applies to private runs — public runs always use LLMs. Default false.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: file_size_mb (required), num_columns (required), num_rows, analysis_depth, +3 more. Returns: result
discovery_get_resultsARead-onlyInspect
Fetch the full results of a completed Disco run.
Returns discovered patterns (with conditions, p-values, novelty scores,
citations), feature importance scores, a summary with key insights, column
statistics, and suggestions for what to explore next.
The response includes a `dashboard_urls` object with direct links to each
page of the interactive report — use these to direct the user to the most
relevant view:
- **summary**: AI-generated overview with key insights, novel findings, and plain-language explanation of the most important findings
- **patterns**: Full list of discovered patterns with conditions, effect sizes, p-values, novelty scores, citations, and interactive visualisations
- **features**: Feature importances, feature statistics and distribution plots, and correlation matrix
- **territory**: Interactive 3D map showing how patterns select different regions of the data
Only call this after discovery_status returns "completed".
Args:
run_id: The run ID returned by discovery_analyze.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: run_id (required), api_key. Returns: result
discovery_list_plansARead-onlyInspect
List available Disco plans with pricing.
No authentication required. Returns all available subscription tiers with credit allowances and pricing. Use this to help users choose a plan.
Inputs: no named parameters. Returns: result
discovery_loginAIdempotentInspect
Get a new API key for an existing Disco account.
Sends a 6-digit verification code to the email address. Call
discovery_login_verify with the code to receive a new API key.
Use this when you need an API key for an account that already exists
(e.g. the key was lost or this is a new agent session).
Returns 404 if no account exists with this email — use discovery_signup instead.
Args:
email: Email address of the existing account.
Inputs: email (required). Returns: result
discovery_login_verifyAIdempotentInspect
Complete login and receive a new API key.
Call this after discovery_login returns {"status": "verification_required"}.
The user receives a 6-digit code by email — pass it here along with the
same email address. Returns a new API key on success.
Args:
email: Email address used in the discovery_login call.
code: 6-digit verification code from the email.
Inputs: email (required), code (required). Returns: result
discovery_purchase_creditsADestructiveInspect
Purchase Disco credit packs using a stored payment method.
Credits cost $0.10 each, sold in packs of 100 ($10/pack). Credits are used
for private analyses (public analyses are free). Requires a payment method
on file — use discovery_add_payment_method first.
Args:
packs: Number of 100-credit packs to purchase. Default 1.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: packs, api_key. Returns: result
discovery_signupAIdempotentInspect
Create a Disco account and get an API key.
Provide an email address to start the signup flow. If email verification
is required, returns {"status": "verification_required"} — the user will
receive a 6-digit code by email, then call discovery_signup_verify to
complete signup and receive the API key. The free tier (10 credits/month,
unlimited public runs) is active immediately. No authentication required.
Returns 409 if the email is already registered.
Args:
email: Email address for the new account.
name: Display name (optional — defaults to email local part).
Inputs: email (required), name. Returns: result
discovery_signup_verifyAIdempotentInspect
Complete Disco signup using an email verification code.
Call this after discovery_signup returns {"status": "verification_required"}.
The user receives a 6-digit code by email — pass it here along with the
same email address used in discovery_signup. Returns an API key on success.
Args:
email: Email address used in the discovery_signup call.
code: 6-digit verification code from the email.
Inputs: email (required), code (required). Returns: result
discovery_statusARead-onlyInspect
Check the status of a Disco run.
Returns current status and progress details:
- status: "pending" | "processing" | "completed" | "failed"
- job_status: underlying job queue status
- queue_position: position in queue when pending (1 = next up)
- current_step: active pipeline step (preprocessing, training, interpreting, reporting)
- estimated_seconds: estimated total processing time in seconds
- estimated_wait_seconds: estimated queue wait time in seconds (pending only)
Poll this after calling discovery_analyze — runs typically take 3–15 minutes.
Use discovery_get_results to fetch full results once status is "completed".
Args:
run_id: The run ID returned by discovery_analyze.
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: run_id (required), api_key. Returns: result
discovery_subscribeADestructiveIdempotentInspect
Subscribe to or change your Disco plan.
Available plans:
- "free_tier": Explorer — free, 10 credits/month
- "tier_1": Researcher — $49/month, 50 credits/month
- "tier_2": Team — $199/month, 200 credits/month
Paid plans require a payment method on file. Credits roll over on paid plans.
Args:
plan: Plan tier ID ("free_tier", "tier_1", or "tier_2").
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: plan (required), api_key. Returns: result
discovery_uploadAInspect
Upload a dataset file and return a file reference for use with discovery_analyze.
Call this before discovery_analyze. Pass the returned result directly to
discovery_analyze as the file_ref argument.
Provide exactly one of: file_url, file_path, or file_content.
Args:
file_url: A publicly accessible http/https URL. The server downloads it directly.
Best option for remote datasets.
file_path: Absolute path to a local file. Only works when running the MCP server
locally (not the hosted version). Streams the file directly — no size limit.
file_content: File contents, base64-encoded. For small files when a URL or path
isn't available. Limited by the model's context window.
file_name: Filename with extension (e.g. "data.csv"), for format detection.
Only used with file_content. Default: "data.csv".
api_key: Disco API key (disco_...). Optional if DISCOVERY_API_KEY env var is set.
Inputs: file_content, file_name, file_path, file_url, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Each tool has a clearly distinct purpose with no overlap. Account management (discovery_account, discovery_add_payment_method), authentication (discovery_login, discovery_login_verify, discovery_signup, discovery_signup_verify), analysis workflow (discovery_upload, discovery_estimate, discovery_analyze, discovery_status, discovery_get_results), and billing (discovery_list_plans, discovery_purchase_credits, discovery_subscribe) are all cleanly separated. An agent can easily distinguish between tools like discovery_analyze (run analysis) and discovery_estimate (check cost/time) despite both relating to analysis preparation.
All 14 tools follow a perfect 'discovery_verb_noun' pattern with consistent snake_case throughout. The naming convention is highly predictable: discovery_account, discovery_analyze, discovery_estimate, discovery_get_results, discovery_list_plans, etc. This consistency makes the tool set immediately understandable and navigable.
14 tools is ideal for this server's comprehensive scope covering authentication, data upload, analysis execution, results retrieval, and billing management. Each tool serves a specific, necessary function in the end-to-end workflow. The count is neither too thin (missing critical operations) nor bloated (no redundant tools), perfectly matching the domain of a sophisticated data analysis platform.
The tool surface provides complete coverage for the Disco platform's domain. It includes full authentication flow (signup/login with verification), account management, billing operations (plans, payments, credits), data upload, analysis estimation, execution, status monitoring, and results retrieval. There are no dead ends or gaps—every logical step in the workflow has a corresponding tool, creating a coherent end-to-end experience.
Maintenance
Related MCP Connectors
Query your data in plain English or SQL, build datasets, and fit Bayesian models.
Discover AI agent insights, open research questions, and reproducible findings in a public commons.
A public commons for agents to search and share reusable findings and open research questions.
Claimora expands AI agents' research horizons through an interconnected graph of scientific claims, evidence, contradictions, and cross-disciplinary relationships. Discover unexpected research paths, investigate original sources, and return with refined questions to explore further—potentially reducing research time and cost.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables autonomous data exploration on .csv-based datasets, providing intelligent insights with minimal effort.2544MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that enables natural language interaction with Google's Discovery Engine API, allowing users to search, recommend, and manage data through conversational interfaces.-
- FlicenseNot gradedqualityDmaintenanceProvides comprehensive statistical analysis tools for industrial data including time series analysis, correlation calculations, stationarity tests, outlier detection, causal analysis, and forecasting capabilities. Enables data quality assessment and statistical modeling through a FastAPI-based MCP architecture.7-
- FlicenseAqualityDmaintenanceEnables comprehensive analysis of CSV files and SQLite databases through tools for statistics, correlations, anomaly detection, pivot tables, time series analysis, visualization, and automated insights discovery.16-