docs/guides/sanity-mcp-continue-cookbook.mdx
import { OSAutoDetect } from '/snippets/OSAutoDetect.jsx' import CLIInstall from '/snippets/cli-install.mdx'
<OSAutoDetect /> <Card title="What You'll Build" icon="database"> An AI-powered content management system workflow that uses Continue's AI agent with Sanity MCP to manage schemas, execute GROQ queries, handle migrations, and maintain documentation - all through simple natural language prompts </Card>Before starting, ensure you have:
For all options, first: <Steps> <Step title="Install Continue CLI"> <CLIInstall /> </Step>
<Step title="Install Sanity CLI"> ```bash npm install -g @sanity/cli ``` </Step> </Steps> <Warning> To use agents in headless mode, you need a [Continue API key](https://continue.dev/settings/api-keys) and proper environment variable configuration. </Warning>New to Sanity? Follow the Sanity Getting Started Guide to set up your first project.
Quick setup:
npm create sanity@latest
cd your-project-name
npm run dev
Key resources:
After ensuring you meet the Prerequisites above, you have two paths to get started:
<Tabs> <Tab title="⚡ Quick Start (Recommended)"> <Steps> <Step title="Load the Pre-Built Agent"> Visit the [Sanity Assistant Agent](https://continue.dev/continuedev/sanity-assistant-agent) on Continue Mission Control and click **"Install Config"** or run: ```bash
cn --agent continuedev/sanity-assistant-agent
```
This agent includes:
- **[Sanity MCP](https://continue.dev/sanity/sanity-mcp)** pre-configured and ready to use
- **Content management rules** for best practices
- **Schema optimization** guidelines
</Step>
<Step title="Your First MCP Conversation">
Start with these beginner-friendly prompts to explore your content:
```bash
# Content exploration
"Show me all blog posts published in the last month"
# Schema understanding
"Show me all the document types in my Sanity schema and explain their relationships"
# Content management
"Create a new product page for our upcoming feature"
```
That's it! The agent handles everything automatically. For more starter prompts and examples, see the [official Sanity MCP blog post](https://www.sanity.io/blog/introducing-sanity-model-context-protocol-server).
</Step>
</Steps>
<Info>
**Why Use the Agent?** The pre-built Sanity Assistant agent provides consistent content management workflows and handles MCP configuration automatically, making it easier to get started with AI-powered CMS operations. Results are more consistent and debugging is easier thanks to the [Sanity MCP](https://continue.dev/sanity/sanity-mcp) integration and pre-tested prompts.
</Info>
This will add Sanity MCP to your agent's available tools. The Mission Control listing automatically configures the MCP connection.
<Tip>
**Alternative installation methods:**
1. **Quick CLI install**: `cn --mcp sanity/sanity-mcp`
2. **With config**: Use [Sanity MCP Config](https://continue.dev/sanity/sanity-mcp-config) for environment variable setup
3. **Manual configuration**: Add the MCP to your agent configuration
Once installed, Sanity MCP tools become available to your Continue agent for all prompts.
</Tip>
<Info>
**Authentication Options:**
- **Interactive mode**: OAuth authentication via browser (expires after 7 days)
- **Headless/CI mode**: Uses environment variables (SANITY_API_TOKEN, SANITY_PROJECT_ID, etc.)
See [Sanity MCP Config](https://continue.dev/sanity/sanity-mcp-config) for environment variable setup.
</Info>
<Step title="Your First MCP Conversation">
Start with these beginner-friendly prompts:
```bash
cn
# Try these starter prompts:
# "Show me all blog posts published in the last month"
# "Show me all the document types in my Sanity schema and explain their relationships"
# "Create a new product page for our upcoming feature"
```
For more examples, see the [Sanity MCP blog post](https://www.sanity.io/blog/introducing-sanity-model-context-protocol-server).
The agent will automatically detect and use your configuration along with the pre-configured Sanity MCP for content operations. Note that OAuth authentication will be required on first use.
The MCP integrates seamlessly with your existing Sanity workspace, providing AI-powered assistance for both development and content operations. </Card>
With everything set up, you're ready for your first AI-powered content conversation! Try these beginner-friendly starter prompts:
<CardGroup cols={2}> <Card title="Content Discovery" icon="search"> ``` "Show me all blog posts published in the last month" ``` </Card> <Card title="Content Creation" icon="plus"> ``` "Create a new product page for our upcoming feature" ``` </Card> <Card title="Content Updates" icon="edit"> ``` "Update our pricing information across all service pages" ``` </Card> <Card title="Content Scheduling" icon="calendar"> ``` "Schedule the Easter marketing campaign content release for next Tuesday" ``` </Card> </CardGroup> <Info> **New to MCP?** These prompts demonstrate the power of natural language content management. For more examples and detailed explanations, check out the [official Sanity MCP blog post](https://www.sanity.io/blog/introducing-sanity-model-context-protocol-server). </Info>Now you can use natural language prompts to manage your Sanity content and schemas. The Continue agent automatically calls the appropriate Sanity MCP tools.
<Info> You can add prompts to your agent's configuration for easy access in future sessions. Go to your agent in the [Continue Mission Control](https://continue.dev), click **Edit**, and add prompts under the **Prompts** section. </Info> <Info> **Where to run these workflows:** - **IDE Extensions**: Use Continue in VS Code, JetBrains, or other supported IDEs - **Terminal (TUI mode)**: Run `cn` to enter interactive mode, then type your prompts - **CLI (headless mode)**: Use `cn -p "your prompt"` for headless commandsTest in Plan Mode First: Before running operations that might make changes, test your prompts in plan mode (see the Plan Mode Guide; press Shift+Tab to switch modes in TUI/IDE). This shows you what the agent will do without executing it.
To run any of the example prompts below in headless mode, use cn -p "prompt"
</Info>
About the --auto flag: The --auto flag enables tools to run continuously without manual confirmation. This is essential for headless mode where the agent needs to execute multiple tools automatically to complete tasks like schema exploration, GROQ execution, and content migration.
Prompt:
Show me all document types in my Sanity schema with their fields,
validation rules, and relationships to other types.
Prompt:
Run a GROQ query to fetch all articles published in the last 30 days,
including their titles, authors, categories, and view counts.
Prompt:
Find all blog posts with the category "News" and update their
status to "archived" if they are older than 6 months.
Prompt:
Add localization support to my article document type for
Spanish and French languages with appropriate field configurations.
Prompt:
Help me migrate my blog posts from the old schema structure
to the new one, mapping the deprecated fields to the new format.
Prompt:
Generate comprehensive documentation for my Sanity schema including
all document types, their purposes, field descriptions, and usage examples.
Prompt:
List all active releases in my dataset and show me the content
changes scheduled for each release.
Prompt:
Analyze the performance of my most frequent GROQ queries and
suggest optimizations to improve response times.
This example demonstrates a Continuous AI workflow where content validation and schema checks run automatically in your CI/CD pipeline in headless mode using the Sanity agent config. Consider remixing this agent to add your organization's specific content governance rules.
Navigate to Repository Settings → Secrets and variables → Actions and add:
CONTINUE_API_KEY: Your Continue API key from continue.dev/settings/api-keysSANITY_PROJECT_ID: Your Sanity project IDSANITY_DATASET: Your Sanity dataset name (usually "production")SANITY_API_TOKEN: Your Sanity API token with appropriate permissionsMCP_USER_ROLE: Your MCP user role (typically "admin" or "editor")This workflow automatically validates your Sanity schemas and content on pull requests using the Continue CLI in headless mode. It checks schema integrity, validates content relationships, and posts a summary report as a PR comment.
Create .github/workflows/sanity-content-validation.yml in your repository:
name: Sanity Content Validation with MCP
on:
pull_request:
branches: [main]
workflow_dispatch:
jobs:
validate-content:
runs-on: ubuntu-latest
env:
CONTINUE_API_KEY: ${{ secrets.CONTINUE_API_KEY }}
SANITY_PROJECT_ID: ${{ secrets.SANITY_PROJECT_ID }}
SANITY_DATASET: ${{ secrets.SANITY_DATASET }}
SANITY_API_TOKEN: ${{ secrets.SANITY_API_TOKEN }}
MCP_USER_ROLE: ${{ secrets.MCP_USER_ROLE }}
steps:
- uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: "18"
- name: Install Sanity CLI
run: |
npm install -g @sanity/cli
echo "✅ Sanity CLI installed"
- name: Install Continue CLI
run: |
npm install -g @continuedev/cli
echo "✅ Continue CLI installed"
- name: Validate Schema Structure
run: |
echo "🔍 Validating schema structure..."
cn --agent continuedev/sanity-assistant-agent \
-p "Analyze the Sanity schema for any structural issues,
missing required fields, or broken references between document types." \
--auto
- name: Check Content Integrity
run: |
echo "📊 Checking content integrity..."
cn --agent continuedev/sanity-assistant-agent \
-p "Run GROQ queries to identify any orphaned documents,
broken references, or missing required fields in the content." \
--auto
- name: Generate Schema Documentation
run: |
echo "📝 Generating schema documentation..."
cn --agent continuedev/sanity-assistant-agent \
-p "Generate a markdown summary of all schema changes
in this PR and their potential impact on existing content." \
--auto > schema-changes.md
- name: Comment Report on PR
if: always() && github.event_name == 'pull_request'
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
REPORT=$( cn --agent continuedev/sanity-assistant-agent \
-p "Generate a concise summary (200 words or less) of:
- Schema validation results
- Content integrity checks
- Any breaking changes detected
- Recommended actions before merging" \
--auto)
gh pr comment ${{ github.event.pull_request.number }} --body "$REPORT"
Implement automated content quality checks using Continue's rule system. See the Rules deep dive for authoring tips.
<Card title="Schema Validation" icon="check-circle"> ```bash "Before deploying schema changes, validate that all required fields are present and that no breaking changes affect existing content." ``` </Card> <Card title="Content Consistency" icon="shield-exclamation"> ```bash "When creating new content types, ensure they follow the existing naming conventions and field patterns established in the schema." ``` </Card> <Card title="Query Optimization" icon="gauge-high"> ```bash "Review GROQ queries for performance issues and suggest indexes or query restructuring to improve response times." ``` </Card> <Card title="Localization Standards" icon="check-double"> ```bash "Ensure all user-facing content fields have proper localization support configured for the required languages." ``` </Card>"Check if I'm properly authenticated with Sanity.
If not, help me set up OAuth or API token authentication."
"Verify that the Sanity project is properly configured
and that the schema files are accessible in the current directory."
"Debug this GROQ query and explain why it's failing,
then provide a corrected version that achieves the intended result."
After completing this guide, you have a complete AI-powered content management system that: