# Paperspace MCP

> Paperspace MCP gives your AI client visibility into complex cloud machine learning environments. Use it to list active compute instances, trace deployed services, inspect Jupyter notebooks, and map user accounts across deep learning infrastructure. It's essential for anyone needing real-time status on GPU resources.

## Overview
- **Category:** superpower
- **Price:** Free
- **Tags:** gpu-provisioning, machine-learning, cloud-computing, jupyter-notebooks, container-management, infrastructure-monitoring

## Description

Managing distributed computing power is a headache until now. This MCP connects your AI agent directly to Paperspace Cloud Insights, giving you an immediate view of every active resource running in the cloud. You can query which physical machine cores are heavily modified or check memory schemas across different compute instances. It’s also great for auditing who has access by checking native identity accounts and tracking team project limits. If your workflow requires knowing the status of deployed containers, this MCP handles that too. This level of deep infrastructure insight is what makes the Vinkius catalog so powerful; you get one connection point to dozens of specialized services. You can use it to inspect raw Jupyter notebooks linked to specific deep learning models or even check if a serverless API container is available by reviewing its logs.

## Tools

### list_machines
Lists all bounded compute resources available within your Paperspace account limits.

### get_machine_details
Extracts detailed properties for a specific machine instance, including its current logic status.

### list_deployments
Retrieves explicit logs and statuses for cloud deployment targets.

### list_notebooks
Inspects deep internal arrays to find details about specific AI workload notebooks.

### list_projects
Enumerate structured project groupings, showing which team limits are currently active.

### get_user_details
Identifies precise account details and associated authentication arrays for the user.

## Prompt Examples

**Prompt:** 
```
Scan Paperspace for any currently active deployed Core machines.
```

**Response:** 
```
Successfully queried physical limit layers. Found 2 virtual Core instances. Instance `ps1aaq4`: P4000 GPU (Off). Instance `ps38jxx`: RTX5000 GPU (Running) allocated 30GB of internal RAM. Should I describe `ps38jxx` deeply?
```

**Prompt:** 
```
Execute an inventory sweep over active Gradient Jupyter Notebooks running in production.
```

**Response:** 
```
Tapped native AI layer arrays determining 1 Gradient environment running explicitly in the background. Token id `nxxx`. Attached to deep learning target container environment. Status: Provisioned. The workspace maps exclusively back to 'Computer Vision Team 1'.
```

**Prompt:** 
```
Show exactly which users are tied down to my native Paperspace environment.
```

**Response:** 
```
Parsed global arrays confirming absolute account identities. Account belongs to "Team Vinkius". Billing Profile: Active Card. Support Plan: Developer. Storage constraint ceiling set to strictly 2000 GB.
```

## Capabilities

### Check active compute resources
Identify all provisioned machine cores, checking their current status and resource limits.

### Audit deployed services
Retrieve logs and statuses for specific cloud deployment targets to ensure containers are available.

### Inspect ML project boundaries
List structured project groupings, verifying team limits and GPU unit assignments across the platform.

### Query notebook usage
Find details on Jupyter notebooks by inspecting deep internal arrays that govern AI workloads.

### Verify user identity access
Identify all linked account identities and associated billing or support plan constraints.

## Use Cases

### Debugging an Overloaded Cluster
A data scientist notices slow model performance. They prompt their agent: 'List all machines and check which ones are hitting memory limits.' The agent uses `list_machines` combined with `get_machine_details` to pinpoint the exact overloaded GPU instance, allowing immediate scaling decisions.

### Auditing Team Access
An infrastructure architect needs to confirm who has access before a major migration. They ask their agent to run `get_user_details` and review all active team limits using `list_projects`, ensuring no unauthorized accounts exist.

### Checking Production Readiness
A DevOps engineer needs to verify if the latest API build is ready. They ask their agent to run `list_deployments` to check container logs, confirming that all required services are reporting 'available' status.

### Investigating Stalled Research
A researcher suspects a Jupyter notebook has crashed without logging off. They prompt their agent to run `list_notebooks`, which retrieves the deep internal arrays and confirms if the workload is still provisioned or stalled.

## Benefits

- Get a precise overview of your hardware. Instead of logging into the console to check available resources, use `list_machines` to get an instant count of all bounded compute instances.
- Audit resource usage quickly. You can run `get_machine_details` on any instance to extract specific properties like memory schemas and storage constraints without manually inspecting dashboards.
- Track team work accurately. Use `list_projects` to see exactly how GPU units are grouped into discrete projects, making it easy to audit team limits.
- Verify container health automatically. Checking deployment logs via `list_deployments` tells you immediately if your serverless API containers are currently active and running correctly.
- Deep dive into research code. If a notebook is behaving strangely, use `list_notebooks` to inspect the underlying deep arrays governing that specific AI workload.

## How It Works

The bottom line is, you tell your AI client what infrastructure detail you need, and it executes the query directly against Paperspace.

1. Subscribe to this MCP in the Vinkius catalog.
2. Provide your Paperspace API Key to your AI client.
3. Use natural language prompts with your agent to monitor specific GPU footprints or deployment logs.

## Frequently Asked Questions

**How does Paperspace MCP help me find an idle GPU?**
You can use `list_machines` to see all available compute resources. Then, prompt your agent to run `get_machine_details` on those IDs to check their current load and memory usage.

**Can I track which team owns a specific project using Paperspace MCP?**
Yes, running `list_projects` enumerates all structured groupings. This tool shows the active team limits attached to specific GPU units.

**What if my container deployment log is corrupted? Can Paperspace MCP help?**
You can use `list_deployments`. The MCP reads explicit cloud logs, which helps verify whether the target deployment status remains active even if other logging methods fail.

**Does Paperspace MCP only work for new ML projects?**
No. It monitors existing infrastructure too. Use `list_notebooks` to inspect old or dormant Jupyter notebooks and check their associated workload limits.

**How do I know which user account is connected to this Paperspace MCP?**
Running the `get_user_details` tool identifies all active account arrays, confirming who has access credentials and what support plan they are under.