# Paperspace MCP for AI Agents AI Agent Connect

> Paperspace MCP lets you manage GPU workloads, deep learning machines, and Jupyter notebooks through your AI client. It tracks active deployments, maps team project limits, and queries cloud environments. Use it to see what is running on your hardware without leaving your workspace.

## Overview
- **Category:** superpower
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_w4nfco02fghsGPeqz307rO7rx1srVWdx33BhZToR/ai-agent-connect
- **Tags:** gpu-provisioning, machine-learning, cloud-computing, jupyter-notebooks, container-management, infrastructure-monitoring

## Description

Manage your high-performance GPU clusters without jumping between different tabs to check which machines are running or which notebooks are pulling the most memory. This Connector brings your Paperspace environment directly into your AI chat. Instead of hunting for specific instance IDs or digging through logs to see if a container is actually live, you can just ask your agent to show you the current state of your hardware. You will see exactly which machines are active, what their memory constraints are, and which Jupyter notebooks are currently tied to your deep learning models. It handles the heavy lifting of mapping out your team's project clusters and checking out the status of your cloud API containers. When you are looking to scale or troubleshoot, this integration gives you a clear view of your footprint across the entire cloud. It is a lot easier to keep your research on track when you can query your infrastructure as easily as you query your code. You can find this and thousands of other tools in the Vinkius catalog to keep your dev stack connected. This setup removes the friction of manual monitoring and lets you focus on training models and analyzing data. You get a direct line to your compute resources, making it simple to verify that your environment is ready for the next run.

## Tools

### list_deployments
Pull explicit Cloud logging and trace your deployment targets. Use this to see if your containers are active.

### list_notebooks
Inspect internal arrays to see which AI workloads are using notebooks. This is great for tracking deep learning tasks.

### list_projects
See the structured rules and team limits for your active projects. It helps you manage your team's budget.

### list_machines
View all your bounded Compute resources in the Headless Paperspace limits. This helps you see what is running at a glance.

### get_machine_details
Get the specific properties and logic driving an active instance. You can check memory and storage constraints quickly.

### get_user_details
Identify the active arrays spanning your native Identity Auth. Use this to check account permissions.

## Prompt Examples

**Prompt:** 
```
I'm not sure which GPU is running my vision model.
```

**Response:** 
```
I checked your active machines and notebooks. Here is what is running:

- **Instance ps1aaq4**: P4000 GPU (Off)
- **Instance ps38jxx**: RTX5000 GPU (Running)
- **Notebook**: nxxx is active and attached to the 'Computer Vision Team 1' workspace.

Would you like me to pull more details on the running instance?
```

**Prompt:** 
```
Did my deployment actually go live?
```

**Response:** 
```
I have pulled the latest cloud logs for your deployments:

- **Status**: Active
- **Container ID**: c-9928
- **Target**: Production API

Your container is live and receiving traffic. Let me know if you need me to check any other targets.
```

**Prompt:** 
```
I need to know the RAM on instance ps38jxx.
```

**Response:** 
```
Here are the details for instance ps38jxx:

- **GPU**: RTX5000
- **Internal RAM**: 30GB
- **Status**: Running
- **Project**: 'Deep Learning Alpha'

Everything looks correct for your current session.
```

## Capabilities

### Identify active GPU machines
See every running machine in your account at a glance.

### Extract instance properties
Get specific details on memory, storage, and hardware specs.

### Trace cloud deployment logs
Check if your API containers are live and see their current status.

### Query active Jupyter notebooks
See which notebooks are currently tied to your deep learning tasks.

### Map team project limits
View the rules and resource boundaries for your team projects.

### Identify account identities
Check the active users and permissions across your environment.

## Use Cases

### Checking GPU availability for a new run
An ML researcher is unsure which machine has free memory. They ask their agent to check for active machines and notebooks using list_machines and list_notebooks.

### Verifying a production deployment
An infra lead needs to know if the new API container is live. They ask the agent to pull the latest cloud logs using list_deployments.

### Audit team project limits
A manager needs to see if the team is staying within the storage ceiling. They ask the agent to show the rules for active projects using list_projects.

### Quick hardware spec check
A developer needs the exact RAM count for a specific instance. They ask the agent to pull the details for instance ps38jxx using get_machine_details.

## Benefits

- Avoid paying for idle hardware by quickly finding active machines with list_machines.
- Plan your training memory by getting instant hardware specs with get_machine_details.
- See if your API containers are live by tracking your deployment status with list_deployments.
- Monitor your research progress by seeing which notebooks are running with list_notebooks.
- Keep your projects within budget by understanding your team's limits with list_projects.
- Manage access across your organization by verifying account permissions with get_user_details.

## How It Works

The bottom line is you get a live dashboard of your machine learning infrastructure inside your AI chat.

1. Connect your Paperspace API Key to the Connector.
2. Open your AI client like Claude or Cursor.
3. Ask for a status update on your GPU fleet.

## Frequently Asked Questions

**Can I see my GPU usage with Paperspace MCP?**
Yes. You can ask your agent to list all active machines and see which ones are running, their status, and their hardware specs.

**How do I check my Jupyter notebooks using Paperspace MCP?**
You can ask your agent to list your notebooks. It will show you which ones are active and which ones are tied to your current deep learning tasks.

**Can Paperspace MCP help me manage my team's project limits?**
Yes. It can pull the structured rules and team limits for your active projects so you can stay within your budget.

**Does Paperspace MCP show my deployment logs?**
It can pull explicit cloud logging for your deployments to help you see if your containers are active and running correctly.

**How do I find active machines on Paperspace MCP?**
Just ask your agent to list your machines. It will provide a summary of your bounded compute resources in your chat window.

**Can I use Paperspace MCP with Cursor or Claude?**
Yes. This Connector is designed to work with any MCP-compatible client, including Claude, Cursor, and Windsurf.

**Are Paperspace Core machines dynamically mapped?**
Yes. The `list_machines` query returns deeply structured attributes associated exactly with the base compute objects provisioning storage arrays, IPs, and states running natively over Paperspace Core.

**Can I spin up new Jupyter Gradient instances?**
Currently, this module focuses strictly on dynamic observability — pulling down Notebooks arrays, Teams constraints, and extracting native deploy mapping contexts. Write operations to spin up environments are out-of-scope for read workflows.

**How do I fetch the resource specs belonging to a specific ID?**
After listing the overall arrays, provide the `psxxxxxx` ID identifier securely to the `get_machine_details` extractor to generate raw hardware limitations mapped logically inside that node.