Skip to main content

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: For all options, first:
1

Install Continue CLI

npm i -g @continuedev/cli
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

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:

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:
To use the pre-built Sanity Assistant agent, you need either:
  • Continue CLI Pro Plan with the models add-on, OR
  • Your own API keys added to Continue Hub secrets
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.

Sanity MCP Capabilities

Understanding the Capabilities

Sanity MCP provides comprehensive tools for content management: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 Hub, 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 cn to 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.
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.TUI Mode Prompt:
Show me all document types in my Sanity schema with their fields,
validation rules, and relationships to other types.
Headless Mode Prompt:
cn -p "Show me all document types in my Sanity schema with their fields, validation rules, and relationships to other types." --auto

GROQ Queries

Execute GROQ Queries

Run GROQ queries to fetch and analyze content.TUI Mode Prompt:
Run a GROQ query to fetch all articles published in the last 30 days,
including their titles, authors, categories, and view counts.
Headless Mode Prompt:
cn -p "Run a GROQ query to fetch all articles published in the last 30 days, including their titles, authors, categories, and view counts." --auto

Content Operations

Bulk Content Updates

Perform bulk operations on your content.TUI Mode Prompt:
Find all blog posts with the category "News" and update their
status to "archived" if they are older than 6 months.
Headless Mode Prompt:
cn -p "Find all blog posts with the category 'News' and update their status to 'archived' if they are older than 6 months." --auto

Localization

Add Localization Support

Set up and manage content translations.TUI Mode Prompt:
Add localization support to my article document type for
Spanish and French languages with appropriate field configurations.
Headless Mode Prompt:
cn -p "Add localization support to my article document type for Spanish and French languages with appropriate field configurations." --auto

Content Migration

Migrate Content Structure

Migrate content between different schemas or environments.TUI Mode Prompt:
Help me migrate my blog posts from the old schema structure
to the new one, mapping the deprecated fields to the new format.
Headless Mode Prompt:
cn -p "Help me migrate my blog posts from the old schema structure to the new one, mapping the deprecated fields to the new format." --auto

Documentation Generation

Generate Schema Documentation

Automatically generate documentation for your content model.TUI Mode Prompt:
Generate comprehensive documentation for my Sanity schema including
all document types, their purposes, field descriptions, and usage examples.
Headless Mode Prompt:
cn -p "Generate comprehensive documentation for my Sanity schema including all document types, their purposes, field descriptions, and usage examples." --auto

Content Releases

Manage Content Releases

Work with Sanity’s content release feature.TUI Mode Prompt:
List all active releases in my dataset and show me the content
changes scheduled for each release.
Headless Mode Prompt:
cn -p "List all active releases in my dataset and show me the content changes scheduled for each release." --auto

Performance Analysis

Analyze Query Performance

Optimize GROQ queries for better performance.TUI Mode Prompt:
Analyze the performance of my most frequent GROQ queries and
suggest optimizations to improve response times.
Headless Mode Prompt:
cn -p "Analyze the performance of my most frequent GROQ queries and suggest optimizations to improve response times." --auto

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 hub.continue.dev/settings/api-keys
  • SANITY_PROJECT_ID: Your Sanity project ID
  • SANITY_DATASET: Your Sanity dataset name (usually “production”)
  • SANITY_API_TOKEN: Your Sanity API token with appropriate permissions
  • MCP_USER_ROLE: Your MCP user role (typically “admin” or “editor”)
The workflow uses the Sanity Agent Config 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 --config continuedev/sanity-agent-config \
             -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 --config continuedev/sanity-agent-config \
             -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 --config continuedev/sanity-agent-config \
             -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 --config continuedev/sanity-agent-config \
             -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 Hub
  • 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

  1. Explore your schema - Try the schema exploration prompt on your current project
  2. Run GROQ queries - Use natural language to query your content
  3. Set up CI validation - Add the GitHub Actions workflow to your repo
  4. Create documentation - Generate comprehensive docs for your content model
  5. Optimize performance - Analyze and improve query performance

Additional Resources

I