# MLflow MCP for AI Agents AI Agent Connect

> MLflow (ML Lifecycle Management) connects your MLflow tracking instance to your AI client. It lets you query training runs, inspect performance metrics, and manage your model registry using natural language. Stop digging through nested dashboards and start asking questions about your experiments directly in your workspace.

## Overview
- **Category:** friends-mcp
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_O0ZBpwFtJKVOQRXy98KSjGZvQNA27XEpDUDcFNyB/ai-agent-connect
- **Tags:** ml-lifecycle, experiment-tracking, model-registry, data-science, reproducibility, mlops

## Description

This MLflow MCP connects your tracking instance to your AI client so you can manage your machine learning experiments and model registry through natural conversation. You can check the status of production models, pull specific telemetry from past experiments, or see where your saved artifacts are stored without leaving your current window. It makes the whole MLOps lifecycle feel like a conversation rather than a series of manual lookups. You will find this in the Vinkius catalog, where it sits alongside other tools designed to give your agent more hands-on control over your technical stack. It turns your training logs into a searchable knowledge base that your agent can actually find and interpret for you.

## Tools

### get_experiment
Retrieve the full configuration and metadata for a specific experiment ID. Use this to see the exact setup of a past project.

### search_runs
Filter and locate specific training runs within a selected experiment. It helps you narrow down hundreds of runs to the few you need.

### get_run
Retrieve the exact parameters and performance metrics for a single run. This gives you a clear view of how one specific session performed.

### search_registered_models
Query the global registry to see which models are active in production. This is the fastest way to audit your live models.

### list_artifacts
Get the file paths and storage locations for artifacts saved during a run. Use this to find the exact location of your model blobs.

### search_experiments
Find specific experiments in your MLflow instance by name or metadata. This helps you quickly locate the right project history.

## Prompt Examples

**Prompt:** 
```
Which models are currently in the production registry?
```

**Response:** 
```
Scanning the global registry... I found 3 models currently in Production:

| Model Name | Version | Status |
| :--- | :--- | :--- |
| Customer-Churn-Classifier | v4 | Production |
| Product-Recommender-Engine | v12 | Production |
| Demand-Forecaster | v2 | Production |

Would you like to see the source run ID for any of these?
```

**Prompt:** 
```
Find the best run for the 'Image Classifier' experiment based on accuracy.
```

**Response:** 
```
Looking through the 'Image Classifier' experiments... I found 15 runs. Here are the top 3 performers:

* **Run_ID_992**: 98.2% Accuracy (Learning Rate: 0.001)
* **Run_ID_441**: 97.5% Accuracy (Learning Rate: 0.002)
* **Run_ID_102**: 96.8% Accuracy (Learning Rate: 0.005)

Would you like me to pull the full parameters for the top run?
```

**Prompt:** 
```
Show me the artifacts for run 'abc-123'.
```

**Response:** 
```
Retrieving artifacts for run 'abc-123'... I found the following files:

* **model.pkl** (Pickled model)
* **confusion_matrix.png** (Visualization)
* **feature_importance.csv**
* **conda.yaml**

I can provide the source tracking path for these files if you need to download them.
```

## Capabilities

### Search historical experiments
Find specific training sessions by name or metadata to see past results.

### Pull run parameters
Get exact metrics and configuration data from a single run ID.

### Identify production models
See which models are currently live or in staging from the global registry.

### Locate saved artifacts
Find the physical storage paths for model blobs and image graphs.

### Compare performance trends
Aggregate logs from multiple sessions to spot accuracy and loss trends.

## Use Cases

### Debugging a failed run
A researcher asks their agent to compare the loss curves of the last five runs to see if a learning rate change helped.

### Production Audit
An MLOps lead asks what models are currently in staging and wants the source run ID for the latest version.

### Artifact Retrieval
An engineer needs to find the specific model.pkl path for a model trained last month to move it to a new environment.

### Rapid Experimentation
A data scientist wants to see the accuracy of all Sentiment Analysis experiments to decide which one to promote.

## Benefits

- Stop manual dashboard hunting by using search_experiments to find the right data instantly.
- Get precise training telemetry from get_run to debug performance spikes in seconds.
- Keep production deployments organized by querying the global registry with search_registered_models.
- Quickly locate saved files and model blobs using list_artifacts to avoid broken paths.
- Compare historical trends across dozens of runs by aggregating logs without manual exports.

## How It Works

The bottom line is you get a conversational interface for your entire MLflow tracking and registry setup.

1. Subscribe to the MLflow MCP on Vinkius.
2. Provide your MLflow Tracking URI and Token in your client settings.
3. Ask your agent to find a specific run or check a model's status.

## Frequently Asked Questions

**Can the MLflow MCP help me find old training runs?**
Yes, it allows your agent to search through your historical experiments by name or metadata to find specific sessions from the past.

**How do I use the MLflow MCP to check production models?**
You can simply ask your agent to query the global registry. It will list which models are currently live, their versions, and their status.

**Can my agent see the specific metrics from an MLflow run?**
Yes, your agent can pull exact parameters and performance metrics for any specific run ID to help you debug or compare results.

**Does the MLflow MCP support looking up saved artifacts?**
It can list the static artifacts attached to a run, such as model files or visualization images, and provide their storage paths.

**How do I connect my MLflow instance to this Connector?**
You just need to provide your MLflow Tracking URI and your Tracking Token in your AI client settings after subscribing on Vinkius.

**Can I use this to compare different MLflow experiments?**
Yes, your agent can aggregate logs from multiple sessions to identify trends and compare model performance across different historical runs.

**Can I see the metrics for a specific training run through my agent?**
Yes. Use the `get_run` tool with a specific Run ID. Your agent will retrieve the detailed telemetry logged during that training session, including scalars like accuracy, loss, or any custom performance metrics you've defined.

**How do I check which models are ready for production in the registry?**
The `search_registered_models` tool allows your agent to query the global model registry. You can identify models that have been explicitly promoted to production or staging environments, helping you track deployment states across your project.

**Can my agent list the plots or model files saved in a specific run?**
Absolutely. Use the `list_artifacts` tool with a specific Run ID. Your agent will report all physical storage boundaries, including stored model blobs (e.g., .pkl, .h5) and saved image plots, ensuring you can locate critical training artifacts instantly.