# Baseten MCP for AI Agents AI Agent Connect

> Baseten MCP lets you manage your Baseten AI models directly through your AI client. It handles model listing, deployment tracking, and serverless inference predictions without you having to juggle multiple terminal windows or complex CLI commands. It's built for teams who need to keep their GPU infrastructure in check while staying focused on building.

## Overview
- **Category:** ai-frontier
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_Iok4x74580t8DfXgX0kQJnXTan6vttePrqZ5XRGU/ai-agent-connect
- **Tags:** model-deployment, inference-api, serverless-ml, model-scaling, mlops

## Description

Managing machine learning infrastructure usually means jumping between cloud consoles, terminal windows, and configuration files just to check a deployment status or run a quick test. This Connector changes that by letting your AI agent handle the heavy lifting of your ML-Ops workflow. Instead of manually tracking replica states or hunting down environment secrets, you can just ask your agent to show you what's running or check your active routing boundaries. It handles the specific details of pushing tensor payloads to your GPU weights so you can focus on the actual research. If you're tired of the friction between your IDE and your inference nodes, this is how you bridge that gap. You can find this and thousands of other tools in the Vinkius catalog to build a more connected workspace. It turns your AI into a capable ML-Ops operator that keeps your GPU lifecycle in check without the constant context switching.

## Tools

### list_models
See all your managed models in one place. This helps you keep track of your entire model fleet.

### get_model
Pull specific details for a single model. Use this to check configurations for a specific model.

### predict
Send tensor payloads or JSON to your GPU weights for a prediction. This runs inference directly.

### list_deployments
See active inference bounds for a specific model. It helps you see what's currently running.

### get_deployment
Get the exact details of a running deployment. This is useful for auditing replica states.

### list_secrets
See your workspace secrets without exposing the actual values. This keeps your environment secure.

## Prompt Examples

**Prompt:** 
```
List the models we have on Baseten.
```

**Response:** 
```
You currently have 3 managed models in your Baseten account:

| Model Name | ID | Status |
| :--- | :--- | :--- |
| **Llama-3-70B-FineTuned** | `lm-9921` | Active |
| **Custom-Vision-V2** | `cv-4432` | Active |
| **Sentiment-Analysis-Lite** | `sa-1102` | Maintenance |

Would you like me to pull the deployment details for any of these?
```

**Prompt:** 
```
Run a prediction on model lm-9921 with the text 'This is a test'.
```

**Response:** 
```
I've sent that text to your Baseten inference node. Here is the result:

**Prediction Result:**
```json
{
  "score": 0.982,
  "label": "POSITIVE",
  "latency": "142ms"
}
```

The prediction was executed successfully against your GPU weights.
```

**Prompt:** 
```
Check if our secret 'HF_TOKEN' is in the workspace.
```

**Response:** 
```
I checked the environment isolation layer for you. 

**Secret Status:**
- `HF_TOKEN`: **Provisioned** ✅
- `OPENAI_API_KEY`: **Provisioned** ✅

I was able to verify the existence of these secrets without retrieving the actual values, keeping your environment secure.
```

## Capabilities

### List all managed models
See every model currently hosted in your Baseten account at a glance.

### Check specific deployment details
Get the exact details of a running deployment including replica states.

### Run inference predictions
Send tensor payloads or JSON directly to your GPU weights for a prediction.

### View workspace secrets
See your securely managed workspace secrets without exposing the actual values.

### Track deployment versions
Monitor your active inference bounds and deployment versions across your models.

## Use Cases

### Testing a new fine-tuned model
A researcher asks their agent to run a prediction on a specific model ID using a custom JSON payload to check for accuracy.

### Debugging a failing deployment
An SRE asks the agent to check the replica states for a specific model to see why a deployment is failing.

### Auditing environment variables
A developer asks the agent to confirm if a specific secret is provisioned in the workspace without showing the actual key.

### Inventorying models
An ML engineer asks the agent to list all models currently hosted on Baseten to prepare for a migration.

## Benefits

- Stop switching tabs by using list_models to see your entire model fleet at once.
- Run predict calls directly in your chat to test payloads without leaving your IDE.
- Audit your infrastructure with list_deployments to see active replica states.
- Securely check your environment with list_secrets to confirm keys are mapped.
- Speed up research by using get_model to pull version schemas instantly.
- Track your GPU lifecycle with automated checks on deployment versions.

## How It Works

The bottom line is you get direct ML-Ops control inside your chat window.

1. Subscribe to the Baseten MCP and enter your API key.
2. Connect the Connector to your preferred AI client like Claude or Cursor.
3. Ask your agent to list models, check deployments, or run predictions.

## Frequently Asked Questions

**Can the Baseten MCP run my models?**
Yes, it lets your agent send payloads to your GPU weights for real-time inference. You just describe the input to your agent, and it handles the prediction call.

**Does it show my secret values?**
No, it only lists the names of your secrets to keep your environment secure. It confirms they are mapped without exposing the actual keys.

**Can I use this with Cursor or Claude?**
Yes, it works with any MCP-compatible client including Claude, Cursor, Windsurf, and VS Code.

**How do I run a prediction using this Connector?**
Simply tell your agent what you want to predict. It will use the predict tool to send the data to your Baseten instance and show you the result.

**Can it check my deployment status?**
Yes, it can pull exact details on replica states and autoscaling configurations, so you can monitor your production environment easily.

**Can the AI agent run a prediction directly against my hosted model?**
Yes. By pushing a correctly formatted JSON payload to the 'predict' tool, the agent securely triggers inference on the GPU instances, returning the exact calculated response data transparently to your editor context.

**Is my workspace and environmental secret data kept safe?**
Baseten secret fetching natively obscures variable values. When you use 'list_secrets', the agent simply evaluates the key names and identifiers existing across your environment to verify configurations without exposing plaintext passwords.

**How do I check auto-scaling configurations for an explicitly deployed model?**
You can examine exactly how instances are managed by using 'get_deployment'. Tell the agent to target an active deployment ID and it maps the scaling limits, replica status, and container bounds out-of-the-box.