# Qovery MCP

> Qovery brings Kubernetes and cloud deployment management right into your chat client. List every environment, check application health, trigger zero-downtime restarts, or deploy a precise Git commit SHA—all without leaving your coding workflow.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** kubernetes, deployment-automation, infrastructure-management, microservices, cloud-ops

## Description

Stop context switching between your IDE and the cloud dashboard just to run basic devops tasks. This MCP connects your Qovery infrastructure directly into any AI client. Instead of navigating through multiple tabs to map out your Organization structure, check specific Project details, or verify an Environment's current status, you talk to your agent. You can ask it to list all applications in a staging environment, grab the replica count for a microservice, or restart pods with a single command. When you need a hotfix deployed—say, testing a new Git commit SHA against development sandboxes—it handles that targeted deployment instantly. Because this MCP lives on Vinkius, your agent gets access to thousands of other tools too. It’s pure infrastructure control, conversationalized.

## Tools

### get_environment
Retrieves specific details and status information for one Qovery environment.

### get_organization
Retrieves details for a specific Qovery organization

### list_organizations
Retrieves a list of all Qovery organizations connected to the provided API token.

### list_projects
Lists all projects that belong within a specific Qovery organization.

### restart_application
Performs an immediate, zero-downtime rolling restart of the target application's pods.

### list_applications
Shows all running applications deployed inside a specified environment.

### list_environments
Lists all active environments (like Production or Staging) within a given project.

### deploy_application
Triggers a fast deployment using a precise Git commit SHA to update the running code.

### get_application
Fetches deep details about a single Qovery application instance.

### get_project
Retrieves comprehensive details for one specific Qovery project.

## Prompt Examples

**Prompt:** 
```
List all Qovery projects and tell me how many there are.
```

**Response:** 
```
Using the `list_projects` tool on your configured organization. I retrieved 3 active projects:
1. 'E-commerce Monolith' (ID: prj-abc123x)
2. 'Payment Gateway' (ID: prj-xyz789y)
3. 'Internal Tools' (ID: prj-def456z)
Would you like to list the environments inside 'Payment Gateway'?
```

**Prompt:** 
```
Check the health and limits of the application in my staging environment.
```

**Response:** 
```
I checked the apps inside environment 'env-stg987'. Found 'web-frontend'.
Limits:
- CPU: 2000m
- RAM: 1024MB
- Replicas: 2 (Auto-scaling off)
It is currently showing as 'HEALTHY' and actively running.
```

**Prompt:** 
```
Deploy commit 7a8f9b2 to the backend application immediately.
```

**Response:** 
```
Sure, I triggered the deployment of commit SHA `7a8f9b2` for the application `backend-api` (id: app-bkn456). The deployment status is now 'DEPLOYING'. We can check back on this in a few minutes.
```

## Capabilities

### Map all organizational deployments
List and navigate through every Qovery Organization, Project, and Environment associated with your account.

### Inspect application health
Retrieve real-time status details for specific applications, including replica counts and auto-scaling settings.

### Cycle running pods
Execute a zero-downtime rolling restart on an application to refresh variables or cycle out old Kubernetes pods.

### Deploy specific commits
Force a targeted deployment of any precise Git commit SHA, perfect for localized hotfixes or feature testing.

## Use Cases

### The Hotfix Scenario
A developer finds a bug in production. Instead of SSHing into a server or manually triggering a deployment, they copy the commit SHA and ask their agent to use `deploy_application` on the specific app in the Production environment. It's instant verification.

### The Scaling Check
An engineering lead needs to confirm if the Payment Gateway is properly scaled after a peak traffic event. They ask their agent, which uses `list_applications` and `get_application`, to report on replica counts across all active environments.

### The Environment Audit
A platform engineer needs to build a map of the company's services. They prompt their agent, which first uses `list_organizations` and then cascades down through `list_projects`, providing a full structural overview.

### The Variable Refresh
A service needs its environment variables refreshed without downtime. The engineer simply tells the agent to run a restart using `restart_application` on the affected microservice, and it handles the rolling update automatically.

## Benefits

- Stop clicking through dashboards. Instead of manually navigating to check application states, your agent gets the details instantly using `get_application`.
- No more guessing if a fix deployed correctly. You can issue a fast-track deploy of any specific Git commit SHA directly via `deploy_application`.
- Need to cycle pods for variable changes? Running an app restart is simple: just use `restart_application` and watch the agent handle the zero-downtime process.
- Mapping your infrastructure used to be a multi-step nightmare. Now, you can list all organizations (`list_organizations`) and projects (`list_projects`) in a single chat query.
- Your team saves time by eliminating context switching. You stay in your IDE while performing critical actions like listing environments (`list_environments`) or checking project details (`get_project`).
- This MCP gives you full visibility, allowing you to verify the scaling and health of mission-critical apps across all zones without leaving your desk.

## How It Works

The bottom line is you control your production environment using natural chat conversation, not complex CLI commands or web dashboards.

1. Subscribe to this MCP and supply your Qovery Organization API Token.
2. Your AI agent uses the token to read the structure of your cloud deployments (Organizations, Projects, Environments).
3. You prompt the agent with an action (e.g., 'Restart the Payment Gateway app in staging'), and it executes the command directly against Qovery.

## Frequently Asked Questions

**How do I list all my Qovery organizations with the Qovery MCP?**
You use the `list_organizations` tool to get a full catalog of all connected organizations. This is your first step when mapping out your entire infrastructure.

**Can I restart an application using the restart_application tool?**
Yes, running `restart_application` triggers a zero-downtime rolling restart across the specified pods and environment. It's perfect for refreshing variables without service interruption.

**What information does get_project provide about my Qovery project?**
The `get_project` tool retrieves all key details about a specific project, including its associated environments and applications. It gives you the full context for that development silo.

**How do I deploy a specific version using the Qovery MCP?**
Use `deploy_application` and pass in the precise Git commit SHA. This ensures you are deploying exactly what was tested, eliminating guesswork from manual deployments.

**Does this MCP help with checking environment status?**
Absolutely. You can use `get_environment` to retrieve detailed status checks for any specific environment in your project, confirming its readiness for deployment.

**How do I securely obtain my Qovery API Token?**
Sign in to your Qovery Console. Navigate to your **Organization Settings**, then to the **API Tokens** section. Click **Generate Token** (or Add). Give it a brief name, select the desired roles, and click Create. Copy the static string immediately as it won't be shown again, and paste it to authenticate.

**Can it restart specific microservices?**
Yes. Once you identify the `app_id` using the list components tools, you can instruct your agent to `restart_application`. This triggers a rolling restart exactly as if you clicked 'Restart' on the console. Traffic is routed seamlessly while pods re-initialize.

**What does deploy specific Git commit do?**
Normally, Qovery auto-deploys a branch. With `deploy_application` you can force Qovery to pull a specific commit ID (SHA) and deploy it immediately to an environment. This is perfect for hotfixes, effectively circumventing prolonged CI loops while ensuring zero downtime.

**Is this tool safe to run on production?**
Yes, but with caveats. Standard queries (like listing environments and getting stats) are entirely read-only. However, tools like `restart` and `deploy` are mutating operations. Always make sure you instruct your agent precisely and maintain manual approval checkpoints before executing deployment functions.