Content Management with Sanity MCP and Continue
Set up an AI-powered content management workflow that helps you manage schemas, run GROQ queries, handle documentation, and perform migrations using natural language commands.
What You'll Build
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
Prerequisites
Before starting, ensure you have:
- Continue account with Hub access
- Node.js 20+ installed locally
- A Sanity account and project (free tier works)
- Basic understanding of content management systems
For all options, first:
1
Install Continue CLI
curl -fsSL https://raw.githubusercontent.com/continuedev/continue/main/extensions/cli/scripts/install.sh | bash
2
Install Sanity CLI
npm install -g @sanity/cli
To use agents in headless mode, you need a Continue API key and proper environment variable configuration.
Getting Started with Sanity
Sanity MCP Workflow Options
Fastest Path to Success
Skip the manual setup and use our pre-built Sanity Assistant agent that includes
the Sanity MCP and optimized content management workflows for more consistent results. You can remix this agent to customize it for your specific needs.
After ensuring you meet the Prerequisites above, you have two paths to get started:
1
Load the Pre-Built Agent
Visit the Sanity Assistant Agent on Continue Mission Control and click "Install Config" or run:
cn --agent continuedev/sanity-assistant-agent
This agent includes:
- Sanity MCP pre-configured and ready to use
- Content management rules for best practices
- Schema optimization guidelines
2
Your First MCP Conversation
Start with these beginner-friendly prompts to explore your content:
# 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.
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 integration and pre-tested prompts.
Sanity MCP Capabilities
Understanding the Capabilities
Sanity MCP provides comprehensive tools for content management:
- Execute GROQ queries to fetch and analyze content
- Explore and modify document schemas
- Manage content releases and versions
- Handle content migrations between environments
- Automate documentation generation
- Perform bulk content operations
- Manage localization and translations
The MCP integrates seamlessly with your existing Sanity workspace, providing AI-powered assistance for both development and content operations.
Your First MCP Conversation
With everything set up, you're ready for your first AI-powered content conversation! Try these beginner-friendly starter prompts:
Content Discovery
"Show me all blog posts published in the last month"
Content Creation
"Create a new product page for our upcoming feature"
Content Updates
"Update our pricing information across all service pages"
Content Scheduling
"Schedule the Easter marketing campaign content release for next Tuesday"
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.
Content Management Recipes
Now you can use natural language prompts to manage your Sanity content and schemas. The Continue agent automatically calls the appropriate Sanity MCP tools.
You can add prompts to your agent's configuration for easy access in future sessions. Go to your agent in the Continue Mission Control, click Edit, and add prompts under the Prompts section.
Where to run these workflows:
- IDE Extensions: Use Continue in VS Code, JetBrains, or other supported IDEs
- Terminal (TUI mode): Run
cnto enter interactive mode, then type your prompts - CLI (headless mode): Use
cn -p "your prompt"for headless commands
Test 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"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.Schema Management
Explore Document Types
Review and understand your content schema structure.
Prompt:
Show me all document types in my Sanity schema with their fields,
validation rules, and relationships to other types.
GROQ Queries
Execute GROQ Queries
Run GROQ queries to fetch and analyze content.
Prompt:
Run a GROQ query to fetch all articles published in the last 30 days,
including their titles, authors, categories, and view counts.
Content Operations
Bulk Content Updates
Perform bulk operations on your content.
Prompt:
Find all blog posts with the category "News" and update their
status to "archived" if they are older than 6 months.
Localization
Add Localization Support
Set up and manage content translations.
Prompt:
Add localization support to my article document type for
Spanish and French languages with appropriate field configurations.
Content Migration
Migrate Content Structure
Migrate content between different schemas or environments.
Prompt:
Help me migrate my blog posts from the old schema structure
to the new one, mapping the deprecated fields to the new format.
Documentation Generation
Generate Schema Documentation
Automatically generate documentation for your content model.
Prompt:
Generate comprehensive documentation for my Sanity schema including
all document types, their purposes, field descriptions, and usage examples.
Content Releases
Manage Content Releases
Work with Sanity's content release feature.
Prompt:
List all active releases in my dataset and show me the content
changes scheduled for each release.
Performance Analysis
Analyze Query Performance
Optimize GROQ queries for better performance.
Prompt:
Analyze the performance of my most frequent GROQ queries and
suggest optimizations to improve response times.
Continuous Content Management with GitHub Actions
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.
Add GitHub Secrets
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")
The workflow uses the Sanity Assistant Agent with environment variable authentication via Sanity MCP Config. This enables headless mode operation without OAuth browser authentication.
Create Workflow File
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"
Environment variables enable the MCP to authenticate without OAuth browser prompts. The Sanity MCP Config documentation provides detailed setup instructions for all required variables.
Content Management Best Practices
Implement automated content quality checks using Continue's rule system. See the Rules deep dive for authoring tips.
Schema Validation
"Before deploying schema changes, validate that all required fields
are present and that no breaking changes affect existing content."
Content Consistency
"When creating new content types, ensure they follow the existing
naming conventions and field patterns established in the schema."
Query Optimization
"Review GROQ queries for performance issues and suggest indexes
or query restructuring to improve response times."
Localization Standards
"Ensure all user-facing content fields have proper localization
support configured for the required languages."
Troubleshooting
Authentication Issues
"Check if I'm properly authenticated with Sanity.
If not, help me set up OAuth or API token authentication."
Schema Not Found
"Verify that the Sanity project is properly configured
and that the schema files are accessible in the current directory."
GROQ Query Errors
"Debug this GROQ query and explain why it's failing,
then provide a corrected version that achieves the intended result."
Migration Conflicts
Verification Steps:
- Sanity MCP is installed via Continue Mission Control
- Project is authenticated with Sanity
- Schema files are present and valid
- Dataset permissions are correctly configured
What You've Built
After completing this guide, you have a complete AI-powered content management system that:
- ✅ Uses natural language — Simple prompts instead of complex CMS commands
- ✅ Manages schemas automatically — AI handles schema evolution and migrations
- ✅ Runs continuously — Automated validation in CI/CD pipelines
- ✅ Ensures quality — Content checks prevent broken references and invalid data
Continuous AI
Your content management workflow now operates at Level 2 Continuous
AI -
AI handles routine content operations and schema management with human oversight
through review and approval of changes.
Next Steps
- Explore your schema - Try the schema exploration prompt on your current project
- Run GROQ queries - Use natural language to query your content
- Set up CI validation - Add the GitHub Actions workflow to your repo
- Create documentation - Generate comprehensive docs for your content model
- Optimize performance - Analyze and improve query performance