# Neptune.ai MCP for AI Agents AI Agent Connect

> Neptune.ai MCP for AI Agents. Manage your machine learning experiments, track training runs, and audit model versions directly through your AI client. Connect your Neptune.ai account to query metrics, find specific historical runs, and manage your model registry using natural conversation instead of clicking through dashboards.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_HI0D1zHVFTWAvCQH47Rd6lplgg0GBJXVQZ0fMTHm/ai-agent-connect
- **Tags:** mlops, experiment-tracking, model-versioning, training-metrics, data-science, telemetry

## Description

Managing machine learning experiments usually feels like a chore of constant tab-switching and manual data logging. You spend half your day hunting for that one specific training run that actually hit your accuracy target or trying to remember which version of a model is actually stable for production. This Connector changes that by letting your AI agent do the heavy lifting. Instead of digging through the Neptune.ai dashboard, you can just ask your agent to pull the latest loss curves, compare attributes between two different runs, or list out your promoted models. It bridges the gap between your experimentation data and your daily workflow. You can check your workspace footprint, verify user credentials, and grab precise JSON representations of project metadata without leaving your chat interface. Because Vinkius makes it easy to connect these types of tools, you can get your ML telemetry into your agent in minutes. It's about getting answers faster so you can spend more time on the actual science.

## Tools

### get_attributes
Get parameters mapped within an experiment runtime bounds. Use this to see exact variables like learning rates.

### list_projects
List all accessible Neptune workspaces and projects. Use this to get a high-level overview of your research footprint.

### get_project
Get specific details for a targeted Neptune ML project. This pulls precise metadata for a single workspace.

### search_runs
Search explicitly tracked ML experimentation runs inside a project. It helps you find historical checkpoints quickly.

### get_user
Get specific user credentials and availability details. Use this to verify identities bound to your service account.

### list_models
List trained tracking models packaged natively within a project. This helps you isolate stable versions from test runs.

## Prompt Examples

**Prompt:** 
```
What were the best results for my churn project?
```

**Response:** 
```
I've analyzed the runs for the 'Churn-Prediction' project. Here are the top 3 performers:

| Run ID | Accuracy | Validation Loss |
| :--- | :--- | :--- |
| **churn-exp-123** | **92.4%** | 0.15 |
| churn-exp-120 | 91.8% | 0.18 |
| churn-baseline | 85.2% | 0.24 |

Would you like to see the full attribute list for **churn-exp-123**?
```

**Prompt:** 
```
Show me the learning rate for the latest run.
```

**Response:** 
```
Retrieving attributes for the most recent run... 

For run **'churn-exp-123'**: 
- **Learning Rate**: 0.001 
- **Batch Size**: 32 
- **Optimizer**: Adam 

No anomalous gradients were detected during the final epochs. Do you want the full JSON of all 45 logged attributes?
```

**Prompt:** 
```
Which models are ready for production?
```

**Response:** 
```
I've identified 3 promoted models in the 'Fraud-Detection' project:

* **XGBoost-Classifier-v2** (Production Ready)
* **RandomForest-Baseline** (Staging)
* **NeuralNet-Prod-v1** (Production Ready)

All models are mapped to production-ready weights. Which one would you like to inspect for version history?
```

## Capabilities

### List all ML projects
See your entire workspace footprint and project list in one go.

### Pull project details
Get specific metadata for a targeted Neptune ML project.

### Search historical runs
Locate specific training runs or experiment checkpoints inside a project.

### Extract run attributes
Retrieve exact variables, accuracy metrics, and loss curves from a run.

### View promoted models
Identify and list trained models that were explicitly promoted for use.

### Check user availability
Verify user identifies and availability bound to your active service account.

## Use Cases

### Comparing accuracy across churn experiments
A data scientist needs to find the best run for a churn project. They ask the agent to search_runs and compare accuracy metrics.

### Auditing the production model registry
An ML engineer wants to see what models are ready for production. They use list_models to verify which weights are promoted.

### Retrieving hyperparameter logs
A researcher needs to check the learning rate of a failed run. They use get_attributes to see the specific parameters logged.

### Mapping research footprint
A team lead wants to see all active projects. They use list_projects to get a high-level overview of the research footprint.

## Benefits

- Stop clicking through dashboards by using list_projects to see your entire workspace footprint instantly.
- Find specific experiments faster with search_runs to locate historical checkpoints without manual filtering.
- Compare performance data across runs using get_attributes to see exact loss curves and accuracy metrics.
- Keep production stable by using list_models to identify promoted models and isolate them from test runs.
- Save time on metadata collection by using get_project to pull JSON representations of project configurations.
- Verify your access levels quickly with get_user to ensure your service account has the right permissions.

## How It Works

The bottom line is you get direct, conversational access to your entire ML experiment history without leaving your AI client.

1. Subscribe to the Neptune.ai MCP on the Vinkius Marketplace.
2. Input your Neptune.ai API Token into your AI client configuration.
3. Start asking your agent to pull metrics, list models, or search training runs.

## Frequently Asked Questions

**Can I use the Neptune.ai MCP to see my training metrics?**
Yes. You can ask your agent to pull specific metrics like accuracy, loss curves, or any other telemetry logged during your runs.

**How does the Neptune.ai MCP help with model versioning?**
It allows you to list and view promoted models, making it easy to distinguish stable production versions from ephemeral test runs.

**Can my AI agent list all my Neptune.ai projects?**
Yes, your agent can pull a full list of your Neptune workspaces and projects to give you a high-level overview of your research footprint.

**Does the Neptune.ai MCP support getting JSON metadata?**
Yes. You can request precise JSON representations of specific projects or runs to get deep-dive details into your configurations.

**How do I use Neptune.ai MCP to find specific experiment runs?**
Just ask your agent to search for a run by name or criteria. It will scan your project history and return the specific checkpoints you need.

**Can I check user permissions with the Neptune.ai MCP?**
Yes, you can verify specific user credentials and availability bound to your active service account to ensure proper access.

**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.