Neptune.ai MCP. Audit model versions and run metrics via conversation.
Works with every AI agent you already use
…and any MCP-compatible client
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.
Retrieves a list of workspaces and projects you have access to.
Fetches specific configuration details for one targeted Neptune ML project.
Finds and lists all tracked ML experimentation runs within a specified project.
Lists every trained tracking model packaged and logged inside an existing project.
Retrieves detailed attributes, including accuracy, loss curves, and key variables, from a specific run ID.
Verifies your service account credentials and availability details against the active token.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
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.
019d75dcget attributes
Retrieves specific performance metrics and parameters logged during a defined experiment runtime.
019d75dcget project
Gets the full details for a specified Neptune ML project, including metadata and configuration.
019d75dcget user
Checks your current user credentials and confirms service account availability status.
019d75dclist models
Lists all trained, packaged models that have been logged within a specific project.
019d75dclist projects
Provides an enumeration of all accessible Neptune workspaces and ML projects.
019d75dcsearch 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
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 Subscribe to this server and provide your Neptune.ai API Token.
- 2 Your AI client uses tools like
list_projectsorsearch_runsto discover the required data set. - 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.
Uses list_models and get_attributes to audit the model registry, verifying version history and performance metrics without leaving their terminal.
Calls search_runs to compare baseline models against new experiments. They use get_project to understand the scope of their current research effort.
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_runsto 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_modelstool 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_projectsgives 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_attributespulls precise JSON representations of variables, accuracy scores, and loss curves for any run ID. - Verify access permissions upfront. Use
get_userbefore 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
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.
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.
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.
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
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
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Kanye.Rest
Get random inspirational quotes from Kanye West directly in your AI agent via the Kanye.Rest API.
Groq
Run large language models at unprecedented speed with custom LPU hardware that delivers real-time AI inference at massive scale.
OKLink (Multi-chain Web3 Blockchain Data API)
Access real-time blockchain data across multiple chains—query addresses, tokens, transactions, and blocks directly from your AI agent.
You might also like
Salesloft
Automate sales engagement via Salesloft — manage cadences, people, and accounts directly from any AI agent.
N-Gram Frequency Engine
Exact deterministic unigram, bigram, and trigram counting over huge texts. Save tokens and guarantee 100% accurate phrase counts.
Persana AI
Enrich leads with AI that researches prospects, scores intent signals, and builds personalized outreach sequences automatically.