# Assertible MCP for AI Agents AI Agent Connect

> Assertible helps you manage API testing and monitoring through your AI agent. Instead of jumping between the Assertible dashboard and your terminal, you can trigger deployments, run specific test suites, and sync OpenAPI specs with a few words. It bridges the gap between your code and your production health.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_j2b1fGA9QZp77KBXLw34HQRPgprjB0X3YhgDhJPG/ai-agent-connect
- **Tags:** api-testing, continuous-testing, api-monitoring, json-schema, deployment-tracking

## Description

Managing API health usually means juggling a dozen tabs. You're checking if the latest deploy broke the production endpoint, manually syncing Swagger files, and hunting for the right test suite to run after a hotfix. This Connector changes that by bringing Assertible directly into your AI workflow. You can ask your agent to check a service's status or trigger a full test run immediately after you push code. It handles the heavy lifting of finding the right tests and reporting back the results. When you're using Vinkius to manage your toolset, Assertible fits right in as the bridge between your development environment and your production monitoring. You'll stop copy-pasting status badges into Slack and start getting real-time feedback on your API's reliability. It's about having a clear picture of your service's health without the manual overhead of navigating a complex UI every time you need a simple status update or a quick validation check.

## Tools

### get_service_status_badge
Pull the status badge for an entire service. It's the fastest way to get a high-level health overview for a service.

### create_deployment
Create a new deployment and trigger the associated tests. This automates the handoff from code push to test results.

### get_test_status_badge
Get the markdown and URL for a specific test's status badge. This helps you quickly display health info in docs or Slack.

### run_service_tests
Run every test associated with a specific service. Use this to ensure a full suite passes after a major update.

### run_specific_test
Execute a single, targeted test by its ID. This is perfect for verifying a specific fix without running everything.

### sync_specification
Sync your OpenAPI, Swagger, or Postman specs to Assertible. It keeps your testing environment aligned with your actual code.

### validate_json
Check a JSON document against a JSON Schema Draft 4. Use this to catch formatting errors before they hit your pipeline.

## Prompt Examples

**Prompt:** 
```
Run the tests for the auth service.
```

**Response:** 
```
**Action Initiated**

I've triggered the full test suite for the auth service. 

| Service | Status | Progress |
| :--- | :--- | :--- |
| Auth Service | Running | 15% |

I'll monitor the progress and let you know as soon as the results are in.
```

**Prompt:** 
```
Sync the latest Swagger spec for our payment gateway.
```

**Response:** 
```
I'm syncing your payment gateway specification to Assertible now. 

**Sync Status:**
- Source: Local Swagger File
- Target: Assertible Environment
- Status: In Progress

I'll let you know once the sync is complete and your tests are updated.
```

**Prompt:** 
```
Give me the status badge for the production API.
```

**Response:** 
```
Here is the status badge for the production API:

`![Status](https://assertible.com/badges/prod-api-status)`

**Markdown:**
`![Status](https://assertible.com/badges/prod-api-status)`
```

## Capabilities

### Trigger test runs
Start full service tests or specific ones with a simple command.

### Deploy new versions
Create deployments and kick off automated tests in one go.

### Sync API specs
Keep your OpenAPI, Swagger, or Postman docs in sync automatically.

### Get status badges
Pull markdown and URLs for service health badges instantly.

### Validate JSON
Check your JSON documents against Draft 4 schemas on the fly.

## Use Cases

### Post-deployment verification
A developer pushes a hotfix and asks the agent to run the production suite to confirm the fix using `run_service_tests`.

### Documentation sync
A backend dev updates an endpoint and tells the agent to sync the new Swagger spec to Assertible using `sync_specification`.

### Status badge updates
A team lead wants to grab a status badge for the staging environment to put into a shared dashboard using `get_service_status_badge`.

### Schema validation
A developer wants to check if a new JSON payload meets the required Draft 4 schema before sending it to the API using `validate_json`.

## Benefits

- Stop manual status checks: Use `get_service_status_badge` to get instant health updates without opening a browser.
- Faster deployment cycles: Use `create_deployment` to trigger tests the moment you're ready for a new version.
- Always accurate specs: Use `sync_specification` to ensure your tests always match your latest OpenAPI or Swagger files.
- Targeted QA: Use `run_specific_test` to verify individual fixes quickly instead of waiting for a full suite to finish.
- Proactive error catching: Use `validate_json` to catch schema mismatches during the development phase rather than in production.

## How It Works

The bottom line is you get a direct line to your API testing suite without leaving your editor.

1. Connect your Assertible account by providing your API token.
2. Tell your AI client what you need to do, like running a test or syncing a spec.
3. Get the results or confirmation directly in your chat interface.

## Frequently Asked Questions

**What can I do with the Assertible MCP?**
You can use your AI agent to trigger API test runs, manage deployments, sync your OpenAPI specifications, and check service health status without leaving your current workspace.

**How does Assertible help with API testing?**
It automates the execution of your test suites. Instead of running commands manually, you can ask your agent to run specific tests or full service suites to verify your API's health.

**Can I use Assertible to sync my Swagger files?**
Yes, the Connector allows your AI agent to automatically sync OpenAPI, Swagger, or Postman specifications, ensuring your tests always match your latest code changes.

**How do I trigger tests after a deployment?**
You can simply tell your AI agent to create a deployment and trigger the associated tests. It handles the communication with Assertible to start the process immediately.

**Can the Assertible MCP validate my JSON schemas?**
Yes, it can validate JSON documents against a JSON Schema Draft 4. This is great for catching formatting errors during development before they reach production.

**How does this help with DevOps monitoring?**
It provides a direct way to retrieve status badges and health information for your services. You can get these updates instantly through your AI client for faster monitoring.

**Is Assertible MCP good for QA engineers?**
It's a great tool for QA engineers who need to run targeted test suites quickly. It removes the need to hunt for test IDs or navigate complex dashboards for every single check.

**Can I trigger a full test suite run after a new deployment?**
Yes. Use the `create_deployment` tool. It tracks the deployment to your environment and automatically triggers the associated test runs for that service.

**How do I keep my tests in sync with my OpenAPI documentation?**
You can use the `sync_specification` tool with your Import ID. This ensures your Assertible tests stay up-to-date with any changes in your Swagger or OpenAPI files.

**Is it possible to check the current status of a service for a README file?**
Absolutely. Use `get_service_status_badge` to retrieve the markdown and URL for a status badge, which you can then embed directly into your documentation.