# Apiary MCP for AI Agents AI Agent Connect

> Apiary MCP. Manage your API design-first workflows by letting your AI agent read blueprints, publish documentation, and run validation tests. It connects your Apiary workspace to your agent so you can handle specifications through natural conversation instead of constant context switching.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_UAsHBD3gjamXcRpVpwIeIHmn77OKcfcfMA4F8oBO/ai-agent-connect
- **Tags:** api-design, swagger, documentation, api-blueprints, rest-api, workflow-automation

## Description

Apiary lets you manage your API design-first workflows by connecting your workspace directly to your AI agent. Instead of jumping between your editor and a browser tab to check specifications, you can ask your agent to pull the latest blueprints or push updates. This Connector turns your API management into a conversation. You can have your agent fetch raw Markdown or Swagger files, analyze the endpoints, and then push new code back to the platform. When you're ready to go live, you don't have to manually copy-paste anything. You just tell your agent to publish the new documentation, and Apiary handles the sync for mock servers and public docs automatically. Because Vinkius makes it so easy to connect these types of tools, you can actually stay in your flow. It turns API management from a chore of manual updates into a conversation where your agent does the heavy lifting of fetching, validating, and publishing. You get a single source of truth that stays updated without the usual friction of manual entry. This means your frontend team always has the right links, and your backend team never has to worry about documentation drift. It's about moving faster without breaking things. By automating the boring parts of the lifecycle, you can focus on actual engineering. Whether you're updating a single endpoint or refactoring an entire service, the agent ensures that your documentation is never an afterthought.

## Tools

### list_apis
See every API project currently hosted in your Apiary workspace. This helps you get a quick overview of your entire portfolio.

### get_api
Pull the full source code of a specific API Blueprint. You can use this to feed the latest specs into your agent for analysis.

### run_tests
Trigger Dredd-style tests to validate your backend against your blueprint. This catches errors before they reach your users.

### get_me
View your own authenticated user profile details. Use this to check your account status and permissions.

### list_team_apis
Find all API projects belonging to a specific team. It is useful for seeing what projects a specific group owns.

### list_teams
See all the different teams you belong to in Apiary. Use this to navigate your organization's workspace.

### get_team
Pull the specific details and metadata for a single team. This helps you see the scope and members of a specific group.

### list_team_members
See a full list of people who are members of a specific team. This is great for managing permissions and oversight.

### publish_blueprint
Update a project's Blueprint with valid Markdown or Swagger code. This ensures your live documentation stays in sync with your latest changes.

### get_doc_url
Grab the live documentation and mock server URLs for an API project. Use this to share the correct links with your frontend team.

## Prompt Examples

**Prompt:** 
```
Can you pull the latest blueprint for our 'user-auth' project and tell me what the login endpoint looks like?
```

**Response:** 
```
I've fetched the current Blueprint for **user-auth**. Here are the details for the login endpoint:

| Method | Path | Description |
| :--- | :--- | :--- |
| `POST` | `/v1/auth/login` | Authenticates users and returns a JWT |

**Parameters:**
- `username` (string, required)
- `password` (string, required)

Would you like me to make any changes to this specification?
```

**Prompt:** 
```
I've updated the password requirements in my code. Can you update the Apiary blueprint to reflect that and publish it?
```

**Response:** 
```
I've updated the password requirements in the Blueprint. 

**Changes made:**
- Updated `password` description to require 12+ characters.
- Added `special_characters` requirement to the validation logic.

I have also successfully published these changes to your Apiary project. Your mock servers and public documentation are now updated automatically.
```

**Prompt:** 
```
Show me all the APIs our team owns and tell me if the tests are passing for any of them.
```

**Response:** 
```
Here are the APIs owned by your team:

- **Payments Gateway**: ✅ Tests Passing
- **User Profile**: ✅ Tests Passing
- **Inventory Sync**: ❌ Tests Failing (3 errors found)

Would you like me to run a fresh set of tests on the Inventory Sync project to see the latest results?
```

## Capabilities

### Fetch API blueprints
Pull the raw Markdown or Swagger source code for any project in your workspace.

### Update project documentation
Push new blueprint code directly to Apiary to sync your live docs and mock servers.

### Run Dredd validation tests
Trigger automated tests to verify your backend matches your blueprint specifications.

### List team API projects
Get a complete overview of all APIs owned by a specific team.

### Manage team member permissions
Query and manage team members to keep your engineering workspace secure.

### Retrieve documentation URLs
Get the live links for documentation and mock servers for any project.

## Use Cases

### Updating a new endpoint
A backend dev wants to add a 'refund' endpoint. They ask the agent to fetch the blueprint, add the new endpoint to the Markdown, and then push the updated code back to Apiary.

### Fixing documentation typos
A tech writer finds a typo in a public doc. They tell the agent to find the project, get the code, fix the typo, and publish it back to Apiary.

### Status reporting for managers
A manager needs a status report. They ask the agent to list all team APIs and then run the validation tests on each to see what's currently passing.

### Onboarding new team members
A new dev joins the team. The manager asks the agent to list team members to see who needs access and then adds them.

## Benefits

- Stop manual copy-pasting by syncing your code directly to your API documentation automatically.
- Validate your backend instantly to catch discrepancies between your code and your specs.
- Keep your team aligned by seeing all projects in a single view.
- Get accurate documentation links immediately for your frontend team.
- Manage permissions easily to keep your workspace secure.
- Stay updated on changes by pulling the latest Markdown source into your agent's context.

## How It Works

The bottom line is you stop tab-switching and start managing your API lifecycle through direct commands.

1. Subscribe to the Apiary MCP on Vinkius
2. Enter your Personal Apiary Token in the configuration
3. Ask your agent to fetch, edit, or publish API blueprints

## Frequently Asked Questions

**How does the Apiary MCP help with my API documentation?**
It connects your agent directly to your Apiary workspace, allowing it to read, update, and publish your blueprints. This means your documentation stays current without you having to manually edit files in a browser.

**Can I use this Connector to run tests on my backend?**
Yes, the Connector can trigger Dredd-style tests against your Apiary project. This lets your agent verify that your actual backend implementation matches the specifications defined in your blueprints.

**Will this Connector automatically update my mock servers?**
Yes, when you use the Connector to publish a new blueprint, Apiary automatically syncs your mock servers and public documentation URLs to match the new specification.

**Can my agent manage my team's API projects?**
The Connector allows your agent to list all APIs for a specific team, list team members, and retrieve team details. It's a way to manage your engineering ecosystem through natural conversation.

**Is this Connector for anyone using Swagger?**
This Connector is specifically for users of the Apiary platform who use their Markdown-based blueprints or Swagger files. It won't work with other documentation platforms.

**How do I connect my Apiary account to my agent?**
You just need to subscribe to the Connector and provide your Personal Apiary Token. From there, your agent can start querying your projects and performing actions.

**Can the agent fetch the exact mock server endpoints for one of my APIs?**
Yes. You can use the `get_doc_url` capability to retrieve both the public facing documentation url and the private mock server endpoint string. Your agent can immediately use this url to simulate requests internally using other modules or tests.

**Am I able to update the Blueprint markup completely through the agent?**
Absolutely. Instruct your AI agent to fetch the blueprint with `get_api`. Once read into context, prompt the agent to make your desired changes (e.g. 'Add a new POST route for user creation'). Then, instruct it to use `publish_blueprint` to upload the newly revised markdown.

**How does the team feature list function mapping work?**
Apiary enables collaboration. Utilizing `list_teams`, the agent finds the slugs of your organizations. Then, using `list_team_apis`, it fetches all collaborative APIs available for that precise team. This hierarchy avoids hallucinating random endpoint repositories.