# Mintlify MCP

> Mintlify MCP manages and automates your technical documentation lifecycle directly through natural conversation with your AI agent. Check page view analytics, read project configurations, update metadata settings, or trigger full site deployments—all without leaving the chat window.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** documentation, api-docs, deployment, analytics, technical-writing

## Description

Use this connection to manage every part of your technical documentation process right from your preferred AI client. Instead of logging into a dashboard, navigating through menus, and copying configuration values, you simply ask your agent what you need done. You can retrieve the current project settings or check how many people viewed a specific guide over the last month. Need to push out an emergency update? Triggering a full deployment is as simple as asking for it. This MCP makes managing documentation feel like talking to a teammate who already knows where all the buttons are. It works with Vinkius, making this control layer available across every compatible AI client you use.

## Tools

### get_metadata
Retrieves the current settings and structural data for your Mintlify project.

### get_page_views
Fetches page view statistics, allowing you to track documentation traffic over specific periods.

### trigger_deployment
Forces a new build and deployment of your entire documentation site immediately.

### update_metadata
Modifies various settings within the Mintlify project configuration object.

## Prompt Examples

**Prompt:** 
```
Get the current metadata for my Mintlify project.
```

**Response:** 
```
I've retrieved your project metadata. Your documentation is currently configured with the navigation structure including 'Introduction', 'API Reference', and 'Guides'. Would you like to see the full JSON configuration?
```

**Prompt:** 
```
Show me the page views for the last 30 days.
```

**Response:** 
```
Fetching analytics... In the last 30 days, your documentation received a total of 12,450 page views. The most visited page was '/api-reference/authentication'.
```

**Prompt:** 
```
Trigger a new deployment for my documentation.
```

**Response:** 
```
Deployment triggered successfully! Mintlify is now building the latest version of your documentation. You can check the status in your dashboard.
```

## Capabilities

### Read Project Settings
Retrieve detailed information about your documentation structure and current configuration.

### Modify Documentation Structure
Programmatically change the metadata or settings that control how your documentation is built.

### Analyze Traffic Data
Fetch page view counts and analytics for specific timeframes to gauge user interest.

### Initiate New Builds
Force a new deployment of your entire documentation site, useful for CI/CD pipelines.

## Use Cases

### The Docs Rollout Check
A product manager needs to know if a new guide is getting traction. They ask their agent to run `get_page_views` for the last quarter, instantly showing which pages are gaining momentum and where traffic dropped off.

### The Emergency Hotfix
A developer discovers a critical bug in the docs. Instead of following a multi-step CI/CD process, they instruct their agent to use `trigger_deployment` immediately, getting the fix live within minutes.

### Restructuring Content
The technical writer realizes the navigation flow is confusing. They ask the agent to read the current structure using `get_metadata`, allowing them to revise and then use `update_metadata` without manual admin access.

### Pre-Release Audit
Before a major launch, a developer wants to confirm all project settings are correct. They use the agent to run `get_metadata`, confirming every required API endpoint and setting is correctly configured.

## Benefits

- Stop bouncing between dashboards. You can check page view analytics and project settings—using the `get_page_views` and `get_metadata` tools, for example—all within a single conversation with your agent.
- Build confidence in your deployments. Instead of manually starting a build process, you tell your agent to use `trigger_deployment`, ensuring the latest version is always pushed quickly for testing or release.
- Fix documentation gaps instantly. If a section needs restructuring, you don't need to log into the admin panel; just ask the agent to update settings using `update_metadata` and see it happen.
- Understand user behavior better. Get immediate insights from traffic data by calling `get_page_views`, letting you know exactly which guides users spend their time on.
- Save hours of context switching. You keep your technical writing flow going; the agent handles the backend API calls for metadata management and deployments.

## How It Works

The bottom line is: you talk to your agent; it talks to Mintlify.

1. First, subscribe to the Mintlify MCP and provide your unique API key.
2. Next, give instructions to your AI client, asking it to perform a specific action, like checking traffic or updating settings.
3. Your agent executes the command using the necessary tools and returns the requested data—like an analytics report or a success confirmation.

## Frequently Asked Questions

**How do I check page views using Mintlify MCP?**
You call `get_page_views`. Simply ask your agent for analytics data and specify the time frame you care about. The tool returns a clean summary of traffic, showing total views or specific page counts.

**Can I update my documentation settings with Mintlify MCP?**
Yes, use `update_metadata`. This allows your agent to modify the core configuration object for your project, letting you change things programmatically rather than through a graphical interface.

**How do I force a new deployment using Mintlify MCP?**
Use `trigger_deployment`. You tell your agent to trigger the build. It executes the command and confirms if the latest version is building, which is essential for continuous integration.

**What information does get_metadata provide?**
`get_metadata` retrieves critical data points about your project, including the current navigation structure and key configuration objects needed to understand how Mintlify is built.