Kaggle MCP

Connect Kaggle to VS Code, Cursor and Antigravity chat. Inspect datasets, edit and run notebooks, read available output, and guide research from a question to a measured experiment.

Install and connect

1. Install artifacts/kaggle-mcp-3.0.2.vsix using your editor’s Extensions → … → Install from VSIX menu.
2. Run Kaggle MCP: Open Dashboard.
3. Select Open Kaggle token settings, generate a token at Kaggle’s API settings, paste it into the extension, and select Validate & connect. Current tokens and legacy kaggle.json credentials are supported.
4. Select your editor, enable/trust the Kaggle MCP server in its MCP settings, and start an agent chat.

No Python or separate Node installation is needed by the installed extension. Building requires Node.js 22+ and npm. The host chatbot must support MCP. Keep the originating editor window open while its secure bridge is in use. Cross-editor bridge setup is intended for local editor windows, not SSH/container forwarding.

VS Code supports native MCP discovery; Cursor setup uses ~/.cursor/mcp.json. Current Antigravity setup uses ~/.gemini/config/mcp_config.json and recognizes an existing older ~/.gemini/antigravity/mcp_config.json. Setup preserves other servers and JSONC comments and backs up existing files. Rerun setup when an extension update changes the installed path.

Local notebooks and Kaggle compute

Open a cloud notebook from the Kaggle sidebar to download and edit it locally. Downloads allow 120 seconds per attempt and retry one transient read failure. Source files are stored under kaggle_notebooks/owner/slug/ (with a version subfolder for pinned versions), avoiding collisions between owners. Existing local files are reused when opening the same reference.

In the notebook kernel picker, choose Kaggle Cloud CPU (Run All) or Kaggle Cloud GPU (Run All). Both submit the entire saved notebook as a Kaggle batch run, including when invoked through an individual cell's run button. They are not interactive, cell-by-cell Jupyter connections. Read logs and artifacts in Notebook Output & Logs. The local notebook status bar shows configured hardware; the run status shows reported hardware or UNKNOWN when Kaggle does not report it. Compute executes on Kaggle, not on your local CPU/GPU.

Different notebooks may run independently, subject to Kaggle's own availability and quota. Duplicate submissions for the same owner/slug are blocked across the extension and MCP, including local editor windows. Existing notebooks require a successful status check before submission. A short local lease covers in-flight requests and status propagation (60 seconds after acceptance, 120 seconds after an uncertain submission). Save requests are never automatically retried. This cannot prevent submissions made separately through Kaggle's website or another computer. Account compute inspection samples recent notebooks and is not an exhaustive session inventory.

Research is a first-class workflow

Open Research studio, type a topic such as BCI, and copy the prepared prompt into your AI chat. The chatbot is guided to:

1. Propose 3–5 testable tracks with cited limitations or explicitly unverified candidate gaps, then ask for the user’s preferred area. A preference already supplied is respected.
2. Search datasets and inspect real metadata, versions, licenses and files. Validate labels, independent subjects/sessions and the evaluation split in a loader pilot.
3. Read actual accelerator quota and check a measured experiment budget across every fold, seed and trial. Missing evidence produces needs_validation, not a promise that the experiment fits.
4. Present the plan before remote execution, checkpoint results and verify the actual run status and persisted artifacts.
5. Maintain a project-specific KAGGLE_RESEARCH.md, created with Kaggle MCP: Create Research Plan, to record evidence, datasets, measurements, run versions, results and uncertainties.

The dedicated research playbook and record template are included in the VSIX. The same playbook is available to chatbots through the kaggle://research/guide resource and the kaggle_get_research_guide tool. The tool works without authentication and supports hosts that expose tools but not resources. MCP prompts include kaggle_conduct_research and kaggle_plan_research_experiment. Project rule snippets for Copilot, Cursor and Cline/Roo supplement these capabilities.

The MCP does not search scientific papers itself: the host uses its own literature/search tools. The guide prohibits invented citations, gap statistics, novelty claims, benchmark numbers and runtime measurements. It cannot force every chatbot to obey its guidance.

Kaggle compute planning

Use current account quota, notebook settings and a representative pilot. The playbook records the official notebook documentation’s 12-hour CPU/GPU and 9-hour TPU planning reference, but does not guarantee those budgets for every account or session. It does not hard-code universal RAM, VRAM, input-disk or attachment-count limits. A verified 12-hour session with the planner’s 20% headroom allows 9.6 hours of planned work. This is a planning policy, not a Kaggle runtime limit.

The feasibility tool compares caller-supplied measurements and reports fits_measured_plan, needs_validation, or does_not_fit. It does not execute a benchmark or certify scientific suitability. Quota and dataset inspection tools perform real authenticated API requests. Live account-level behavior still needs verification with a valid Kaggle token.

Chat tools

Push and download tools are marked as mutating. Your host controls approvals. Remote notebook execution consumes Kaggle quota. There is no prediction-submission tool. Logs may arrive after execution; the output view shows API snapshots, not a guaranteed live terminal. Parsed metrics and diagnostic heuristics need validation against the actual experiment.

Credentials

The extension validates and stores tokens in editor SecretStorage. It does not automatically overwrite Kaggle CLI credential files. Explicit import supports existing environment/file credentials. The local bridge stores a short-lived capability in a file restricted to the current OS user; the file contains no Kaggle token. Disconnect removes the extension’s credential, but does not revoke it on Kaggle or delete independently managed CLI credentials. In-flight requests can finish.

For standalone MCP use, run node /absolute/path/to/dist/server.js with KAGGLE_API_TOKEN in its environment, or use the official ~/.kaggle/access_token or ~/.kaggle/kaggle.json. Legacy KAGGLE_USERNAME/KAGGLE_KEY and KAGGLE_CONFIG_DIR are supported. Keep secrets out of chat and committed configuration.

Build and test

npm ci
npm test
npm run test:ui
npm run test:extension
npm run test:live
npm run package

UI tests use installed Google Chrome. Extension-host tests download an isolated VS Code installation. Local tests use fixtures and do not start Kaggle compute jobs. Live smoke tests check deliberately invalid authentication and unauthenticated endpoint behavior; authenticated scientific experiments are not claimed tested. See VALIDATION.md.

Implementation references

Kaggle SDK, Kaggle authentication, notebook specifications, VS Code MCP, Cursor MCP, Antigravity MCP.

Independent extension; not affiliated with Kaggle. MIT licensed. Bundled dependency licenses are in THIRD_PARTY_NOTICES.txt. A local VSIX is built; Marketplace publication is separate.

💡 Creator Message: From Umor Faruk Supto

"Hi everyone! I am Umor Faruk Supto.

I had a little wish when starting this project: to develop Kaggle MCP and make machine learning research, experimentation, and competition workflows faster, simpler, and accessible for everyone.

As researchers, students, and data scientists, we often find ourselves bogged down by constant context switching—jumping between code editors, web browser tabs, terminal windows, and remote notebook sessions just to inspect an epoch log, fetch a dataset, or submit a run. I wanted to remove that friction completely.

With Kaggle MCP, Kaggle's cloud compute (GPUs & TPUs) and massive dataset catalog are bridged straight into your daily development environment and into the hands of autonomous AI assistants like Antigravity, Cursor, Claude, and Copilot.

Whether you are competing for top spots on a Kaggle leaderboard, fine-tuning neural networks, or learning data science, I genuinely hope Kaggle MCP speeds up your discoveries and empowers your research journey. Let's make research faster for everyone!"
— Umor Faruk Supto

Built by Umor Faruk Supto. LinkedIn.