4,500+ servers built on MCP Fusion
Vinkius

Neptune.ai MCP. Audit model versions and run metrics via conversation.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Neptune.ai (ML Experiment Tracking) MCP on Cursor AI Code Editor MCP Client Neptune.ai (ML Experiment Tracking) MCP on Claude Desktop App MCP Integration Neptune.ai (ML Experiment Tracking) MCP on OpenAI Agents SDK MCP Compatible Neptune.ai (ML Experiment Tracking) MCP on Visual Studio Code MCP Extension Client Neptune.ai (ML Experiment Tracking) MCP on GitHub Copilot AI Agent MCP Integration Neptune.ai (ML Experiment Tracking) MCP on Google Gemini AI MCP Integration Neptune.ai (ML Experiment Tracking) MCP on Lovable AI Development MCP Client Neptune.ai (ML Experiment Tracking) MCP on Mistral AI Agents MCP Compatible Neptune.ai (ML Experiment Tracking) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Neptune.ai connects your AI client directly to ML experiment tracking. Run history, model versioning, and training metrics are managed through natural conversation.

Use `list_projects` to map workspaces or `search_runs` to pinpoint specific performance data for any model.

What your AI agents can do

Get attributes

Retrieves specific performance metrics and parameters logged during a defined experiment runtime.

Get project

Gets the full details for a specified Neptune ML project, including metadata and configuration.

Get user

Checks your current user credentials and confirms service account availability status.

+ 3 more capabilities included
List all available ML projects

Retrieves a list of workspaces and projects you have access to.

Get detailed project metadata

Fetches specific configuration details for one targeted Neptune ML project.

Search historical training runs

Finds and lists all tracked ML experimentation runs within a specified project.

Get model inventory for a project

Lists every trained tracking model packaged and logged inside an existing project.

Extract run-specific metrics

Retrieves detailed attributes, including accuracy, loss curves, and key variables, from a specific run ID.

Check user account permissions

Verifies your service account credentials and availability details against the active token.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Neptune.ai (ML Experiment Tracking): 6 Tools for MLOps

Manage ML experiments by listing projects, searching run history, extracting performance attributes, and auditing model versions through conversational API calls.

get019d75dc

get attributes

Retrieves specific performance metrics and parameters logged during a defined experiment runtime.

get019d75dc

get project

Gets the full details for a specified Neptune ML project, including metadata and configuration.

get019d75dc

get user

Checks your current user credentials and confirms service account availability status.

list019d75dc

list models

Lists all trained, packaged models that have been logged within a specific project.

list019d75dc

list projects

Provides an enumeration of all accessible Neptune workspaces and ML projects.

search019d75dc

search runs

Searches through the historical record to locate specific, tracked ML experimentation runs in a project.

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 Neptune.ai (ML Experiment Tracking), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ 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

What you can do with this MCP connector

When you hook up your AI client to this Neptune.ai MCP Server, you get direct command access to your entire machine learning lifecycle—from project setup details right down through model performance metrics. You don't have to navigate dashboards; you just talk to your agent and it does the heavy lifting.

Project Discovery & Setup
You can start by figuring out what workspaces are available. Use list_projects to get an exhaustive list of all Neptune ML projects you've got access to. Once you know which project you wanna dig into, use get_project to pull the full metadata and configuration details for that specific workspace.

This tells you exactly how the environment is set up before you even look at a model.

Searching Historical Runs & Models
If you're auditing old work or trying to replicate a setup, your agent can search deep into history. You use search_runs to pinpoint specific ML experimentation runs within any project. This tool lets you find tracked data and performance boundaries across dozens of training attempts without guessing which run was the winner.

Once those runs are located, you'll need to know what models were packaged with them; call list_models to pull a complete inventory of every trained model that lives inside that project.

Deep Metric Extraction & Analysis
To really understand why one model is better than another, you gotta look at the raw numbers. For any run ID found via searching history, use get_attributes to retrieve precise performance metrics and parameters. This gives you the detailed telemetry—the accuracy scores, the loss curves, or whatever key variables were logged during that specific experiment runtime.

System Status & Permissions
Finally, before you start running complex queries, you should always check your credentials. Call get_user to verify your service account status and confirm that your agent has the proper access scope for all the projects it needs to talk to. It's a quick way to make sure everything's ready.

Here’s what you can do with this server: You can tell your AI client to list every project available, then grab detailed metadata on one of them using get_project. To find specific model outputs, it uses list_models to give you a packaged inventory. If the models are older, you'll use search_runs, which finds all tracked experiment runs in that project.

From those found runs, your agent can grab granular data points—like loss curves or final accuracy—by calling get_attributes. You never forget how to check permissions either; running get_user confirms the service account is active and ready for work.

How Neptune.ai MCP Works

  1. 1 Subscribe to this server and provide your Neptune.ai API Token.
  2. 2 Your AI client uses tools like list_projects or search_runs to discover the required data set.
  3. 3 The agent calls specific functions (e.g., get_attributes) which return structured, actionable data directly into your chat window.

The bottom line is you use natural language with your AI client; the server executes the necessary Neptune API calls and returns the raw results.

Who Is Neptune.ai MCP For?

Data Scientists, ML Engineers, and AI Researchers. This is for people who spend too much time manually clicking through dashboard tabs just to prove a model works. You need an agent that can talk API calls instead of relying on UI filters.

Machine Learning Engineer

Uses list_models and get_attributes to audit the model registry, verifying version history and performance metrics without leaving their terminal.

Data Scientist

Calls search_runs to compare baseline models against new experiments. They use get_project to understand the scope of their current research effort.

AI Researcher

Uses list_projects to map out multiple, disparate ML initiatives and quickly verify which projects have been abandoned or are ready for production.

What Changes When You Connect

  • Pinpoint performance issues instantly. Instead of scrolling through dashboards, use search_runs to find the exact historical experiment that failed or succeeded, giving you a direct link to its parameters.
  • Keep your models segregated from testing noise. The list_models tool ensures you only pull production-ready weights, letting you audit stable versions without sifting through ephemeral test runs.
  • Map out entire research efforts instantly. Calling list_projects gives you a full inventory of every ML initiative you've touched, helping you understand your total research footprint at a glance.
  • Get deep data immediately. You don't have to manually parse logs; get_attributes pulls precise JSON representations of variables, accuracy scores, and loss curves for any run ID.
  • Verify access permissions upfront. Use get_user before running anything big. This checks your service account token status so you know if the agent can actually write or read what it needs.

Real-World Use Cases

01

The Model Drift Audit

A Data Scientist suspects a deployed model is degrading. They ask their agent to run search_runs for that project, filtering by date range. The agent identifies the last 10 runs and uses get_attributes on each one, showing a clear metric drop-off point. The scientist knows exactly when the drift started.

02

Project Scope Mapping

An ML Engineer joins a new team and needs to know what models exist across three different workstreams. They run list_projects, which immediately returns all active workspaces. Then, they call get_project for each one to understand the scope of the historical data.

03

Production Readiness Check

An AI Researcher needs to package a new model variant. They use list_models to see all candidates and confirm that 'v3-production' is logged correctly. If it's missing, they know they need to retrain and log the weights before deployment.

04

Troubleshooting Metrics

A developer gets a run ID from a colleague but needs confirmation on the final performance metrics. They use get_attributes with the specific run ID, instantly pulling the full JSON payload containing validation loss and learning rate details.

The Tradeoffs

Reading Logs Blindly

You open the Neptune dashboard, click into a project, find 50 runs, then click on one run. You have to manually scroll through tabs labeled 'Metrics' and 'Parameters' to find the final accuracy.

Don't read logs blindly. Use search_runs first to narrow down the period or model type. Then, use get_attributes with the specific Run ID to pull the exact metrics JSON directly into your agent chat.

Assuming Model Existence

You assume a team member logged a new version of their fraud detection model and navigate straight to the 'Models' tab, only to find nothing or an old version.

Always check the inventory first. Call list_models for that project. This confirms if any models were actually packaged and logged into Neptune before you try to access them.

Overlooking Project Boundaries

You're working on 'Customer Churn' metrics, but your agent accidentally pulls data from the unrelated 'Inventory Forecasting' project because you didn't specify a scope.

Always start by running list_projects to confirm available scopes. Then, use get_project to lock down and verify the metadata for the correct project boundary before querying any runs or metrics.

When It Fits, When It Doesn't

Use this MCP Server if your workflow requires programmatic access to historical ML experiment data—specifically tracking model versions, run-time metrics, and parameter sets. If you need to compare Model A's loss curve from Run X against Model B's final accuracy on a different date, this is the tool for it.

Don't use this if your primary goal is simple message passing (use a messaging API server) or if you just need to store raw unstructured data without tracking its associated metrics. If you only need to list general workspace names and nothing else, list_projects handles that, but for anything deeper than discovery, the full suite of tools provides necessary depth.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Neptune.ai. 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

How we secure 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 server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

get_attributes get_project get_user list_models list_projects search_runs

Tracking model performance shouldn't involve clicking through 40 dashboard tabs.

Today, auditing an ML model means navigating deep into the Neptune UI. You click 'Projects,' then select a project, then filter for runs in a date range. After finding the right run ID, you still have to open separate tabs—one for parameters, one for metrics, and another for loss curves—and manually copy/paste key data points into a spreadsheet.

With this MCP server, that entire process shrinks down to conversation. Your agent runs `search_runs` first. Then, it calls `get_attributes` on the result. You get the precise variables, metrics, and JSON representation of performance data dumped directly to your chat window. Done.

Neptune.ai MCP Server: Model Versioning

Manually tracking which model version was trained with what hyperparameters, and whether it passed quality checks for production, is a nightmare of screenshots and README files. You waste hours comparing logs to prove consistency.

Now, you use `list_models` directly through your agent. It gives you an immediate inventory of all packaged models in that project—and critically, it tells you which ones are ready for production weights. The history is always visible.

Common Questions About Neptune.ai MCP

How do I find the metrics for a specific run ID using get_attributes? +

You tell your agent to use get_attributes and provide the Run ID. It instantly returns all logged variables, including accuracy, loss curves, and parameters in structured JSON format.

I need to find my active ML projects. Which tool should I use? +

Use list_projects. This command quickly enumerates every accessible workspace and project you have set up within Neptune.ai.

What is the difference between list_models and search_runs? +

search_runs finds historical executions—the actual training job that happened at a specific time. list_models only lists the resulting, packaged model artifacts from those successful runs.

Does get_project give me all the metadata I need? +

Yes. Calling get_project retrieves detailed configuration and metadata for a specific project ID, giving you the full context of that ML initiative.

How do I verify my account access and credentials using get_user? +

It confirms your user ID and checks the availability details tied to your service token. This lets you know immediately if your API key is still active or if there are credential issues blocking access.

Can I use search_runs to filter for runs that hit a specific performance threshold? +

Yes, search_runs allows deep filtering. You pass parameters like minimum accuracy scores or maximum loss values directly into the query. This saves you from reviewing every single run record.

What is the difference between models found via list_models versus runs I find using search_runs? +

The key distinction is stability. list_models only shows trained, promoted models ready for production use. Runs from search_runs include every temporary experiment state and testing iteration.

If I use get_project, do I get the full history of all metrics logged in that project? +

No, get_project provides the overall metadata structure for the project itself. To see specific performance data or metric curves, you must run dedicated queries using tools like search_runs.

Can I see the accuracy metrics for a specific ML run through my agent? +

Yes. Use the get_attributes tool with your Project ID and Run ID. Your agent will retrieve the detailed telemetry logged during that execution, including accuracy, loss, and any custom attributes defined in your code.

How do I check which model versions are currently stable in my registry? +

The list_models tool retrieves all packaged ML models within a project. Your agent will expose the promoted model versions, helping you distinguish between experimental runs and stable candidates ready for deployment.

Can my agent search through hundreds of past ML experimentation runs? +

Absolutely. Use the search_runs tool with your Project ID. Your agent will query Neptune's tracking server to identify historical experiment state checkpoints, making it easy to locate specific training results across your entire research timeline.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 6 tools

We've already built the connector for Neptune.ai. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 6 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.