Connect CandyDocs with AI Agents using MCP

What is MCP?

The Model Context Protocol (MCP) is an open standard that allows AI models to securely connect with external systems such as APIs, databases, and applications.

Instead of just generating text, AI agents can discover available tools and execute real actions through MCP servers.

In simple terms:

AI Agent → MCP Server → CandyDocs APIs → Your Content

The MCP server exposes tools (functions) that AI can call to perform tasks like creating or updating articles.

CandyDocs MCP Server

CandyDocs provides a public MCP server that exposes article management tools.

MCP server endpoint

https://mcp.candydocs.com/mcp

MCP discovery manifest

https://mcp.candydocs.com/.well-known/mcp.json

This file allows AI platforms to automatically detect:

server URL
authentication method
available capabilities

Connect CandyDocs with AI Agents

With MCP integration, AI tools can:

Create new articles
Update existing articles
Delete or manage articles
Fetch article stats and analytics
List articles from your documentation hub

This enables powerful AI workflows such as:

AI writing articles directly into CandyDocs
Automated documentation generation
AI-assisted content editing
Agent-driven knowledge base updates

Available CandyDocs MCP Tools

The CandyDocs MCP server exposes multiple tools that allow AI agents to manage your documentation system including articles, roadmap items, changelogs, wishlist features, and custom pages.

These tools enable AI systems to automate documentation workflows such as content creation, roadmap planning, changelog publishing, and feedback management.

Articles Tools

These tools allow AI agents to create, manage, and analyze documentation articles.

Tool	Description
`list_articles`	Retrieve a paginated list of articles with filters such as search, category, status, and sorting options.
`get_article_by_id`	Fetch full details of a specific article using its ID.
`get_article_stats`	Retrieve analytics and engagement statistics for an article.
`create_article`	Create a new article with content, metadata, SEO fields, tags, and scheduling options.
`update_article`	Update an existing article including content, metadata, SEO settings, and publishing status.
`delete_article`	Delete or deactivate an article from the CandyDocs knowledge base.

Product Roadmap Tools

These tools allow AI agents to manage product roadmap planning and feature tracking.

Tool	Description
`list_roadmap_items`	Retrieve roadmap items with filters such as status, priority, category, and pagination.
`create_roadmap_item`	Create a new roadmap item including title, description, priority, and estimated delivery timeline.
`update_roadmap_item`	Update an existing roadmap item such as status, priority, category, or scheduling details.
`delete_roadmap_item`	Remove or deactivate a roadmap item.

Changelog / Updates Tools

These tools allow AI systems to manage product updates and changelog entries.

Tool	Description
`list_updates`	Retrieve a list of product updates with search, type, and status filters.
`get_update_stats`	Fetch analytics data for a specific update.
`create_update`	Create a new changelog update including title, content, and publication settings.
`update_update`	Update an existing changelog entry.
`delete_update`	Delete or deactivate an update entry.

Wishlist / Feature Requests Tools

These tools allow AI agents to manage user feature requests and feedback.

Tool	Description
`list_wishlist_items`	Retrieve wishlist items with filters such as status, priority, and category.
`get_wishlist_item_by_id`	Fetch detailed information about a specific wishlist item.
`create_wishlist_item`	Submit a new feature request or feedback item.
`update_wishlist_item`	Update wishlist items including status, notes, or metadata.
`delete_wishlist_item`	Delete or deactivate a wishlist item.

Custom Pages Tools

These tools allow AI agents to create and manage custom pages in CandyDocs.

Tool	Description
`list_custom_pages`	Retrieve custom pages with pagination and filters.
`get_custom_page_by_id`	Fetch full details of a custom page by ID.
`create_custom_page`	Create a new custom page including content and SEO metadata.
`update_custom_page`	Update an existing custom page’s content, title, and metadata.
`delete_custom_page`	Delete or deactivate a custom page.

Tool Schema Reference

Developers and AI systems can inspect the full schema definitions here:

https://mcp.candydocs.com/tools/list

This endpoint returns:

tool definitions
input schemas
output schemas
validation rules
authentication requirements

These schemas allow AI agents to safely interact with CandyDocs using structured tool calls.

Prerequisites

Before connecting an AI agent to CandyDocs, make sure you have:

1️⃣ A CandyDocs account
2️⃣ An API key
3️⃣ An AI agent or MCP-compatible client

Examples of MCP-compatible tools:

Claude AI agents
Cursor AI
Cline
OpenAI Agents SDK
Custom AI agents
Enterprise AI assistants

Step 1 — Get Your CandyDocs API Key

Log into your CandyDocs dashboard.

Navigate to:

Settings → API Keys

Generate a new API key.

Example:

pk_live_xxxxxxxxx

You will use this key to authenticate MCP requests.

Step 2 — Configure Your AI Agent

Add the CandyDocs MCP server to your AI agent.

MCP server configuration

Server URL:
https://mcp.candydocs.com/mcp

Authentication:
Bearer API Key

Example header:

Authorization: Bearer pk_live_xxxxxxxxx

Step 3 — Initialize MCP Session

Before calling tools, the client must initialize a session.

Example request:

curl -X POST https://mcp.candydocs.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer pk_live_xxxxxx" \
  -d '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"initialize",
    "params":{}
  }'

The response will include:

mcp-session-id

Save this value for the next requests.

Step 4 — Discover Available Tools

Now the agent can discover the tools exposed by CandyDocs.

Example request:

curl -X POST https://mcp.candydocs.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer pk_live_xxxxxx" \
  -H "mcp-session-id: YOUR_SESSION_ID" \
  -d '{
    "jsonrpc":"2.0",
    "id":2,
    "method":"tools/list",
    "params":{}
  }'

The response will include all Candydocs tools and their schemas.

Step 5 — Call CandyDocs Tools

Once tools are discovered, the AI agent can call them.

Example: Create article

curl -X POST https://mcp.candydocs.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer pk_live_xxxxxx" \
  -H "mcp-session-id: YOUR_SESSION_ID" \
  -d '{
    "jsonrpc":"2.0",
    "id":3,
    "method":"tools/call",
    "params":{
      "name":"create_article",
      "arguments":{
        "apiKey":"pk_live_xxxxxx",
        "origin":"https://docs.yourdomain.com",
        "subdomain":"yourworkspace",
        "title":"Getting Started with CandyDocs",
        "content":"<p>This is an AI-generated article</p>",
        "excerpt":"Learn how to use CandyDocs",
        "category_id":1
      }
    }
  }'

The article will be created in your CandyDocs workspace.

Example AI Workflow

Once connected, AI agents can automate documentation workflows.

Example prompt:

Write a documentation article about our API authentication
and publish it to CandyDocs.

The AI agent will:

1️⃣ Generate article content
2️⃣ Call create_article tool
3️⃣ Publish the article in your knowledge base

Example Use Cases

AI Documentation Writer

Automatically generate documentation for:

APIs
product features
tutorials
onboarding guides

AI Content Editor

Agents can:

update outdated documentation
fix formatting
optimize SEO fields

Automated Knowledge Base

Combine AI with your CI/CD pipeline:

Code changes → AI agent → update docs → publish to CandyDocs

Security Best Practices

When using MCP with CandyDocs:

Always keep your API keys secure
Do not expose API keys in public code

Troubleshooting

MCP server not connecting

Check:

correct MCP URL
valid API key
network access

Tools not appearing

Verify:

tools/list

returns the CandyDocs tools.

Unauthorized errors

Ensure header is set:

Authorization: Bearer API_KEY

CandyDocs MCP Endpoints

Endpoint	Purpose
`/mcp`	MCP server endpoint
`/.well-known/mcp.json`	MCP discovery manifest
`/tools/list`	List available tools

Summary

CandyDocs MCP integration allows AI agents to directly manage your documentation.

With MCP you can:

automate article creation
update knowledge base with AI
integrate AI workflows into your documentation platform
build AI-native documentation pipelines