Allows interacting with the Outline API for document management, including searching, reading, creating, editing, archiving documents, managing collections, adding comments, and more.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-outline search for documents about Q4 goals"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol server for interacting with Outline document management.
Document operations: Search, read, create, edit, archive documents
Collections: List, create, manage document hierarchies
Comments: Add and view threaded comments
Backlinks: Find documents referencing a specific document
MCP Resources: Direct content access via URIs (outline://document/{id}, outline://collection/{id}, etc.)
Automatic rate limiting: Transparent handling of API limits with retry logic
Related MCP server: Outline MCP Server
Before using this MCP server, you need:
An Outline account (cloud hosted or self-hosted)
API key from Outline web UI: Settings → API Keys → Create New
Python 3.10+ (for non-Docker installations)
Getting your API key: Log into Outline → Click your profile → Settings → API Keys → "New API Key". Copy the generated token.
uvx mcp-outlinepip install mcp-outlinedocker run -e OUTLINE_API_KEY=<your-key> ghcr.io/vortiago/mcp-outline:latestOr build from source:
docker buildx build -t mcp-outline .
docker run -e OUTLINE_API_KEY=<your-key> mcp-outlineVariable | Required | Default | Notes |
| Yes | - | Get from Outline web UI: Settings → API Keys → Create New |
| No |
| For self-hosted: |
| No |
|
|
| No |
|
|
| No |
|
|
| No |
| Transport mode: |
| No |
| Server host. Use |
| No |
| HTTP server port (only for |
Configure server permissions to control what operations are allowed:
Set OUTLINE_READ_ONLY=true to enable viewer-only access. Only search, read, export, and collaboration viewing tools are available. All write operations (create, update, move, archive, delete) are disabled.
Use cases:
Shared access for team members who should only view content
Safe integration with AI assistants that should not modify documents
Public or demo instances where content should be protected
Available tools:
Search & Discovery: search_documents, list_collections, get_collection_structure, get_document_id_from_title
Document Reading: read_document, export_document
Comments: list_document_comments, get_comment
Collaboration: get_document_backlinks
Collections: export_collection, export_all_collections
AI: ask_ai_about_documents (if not disabled with OUTLINE_DISABLE_AI_TOOLS)
Set OUTLINE_DISABLE_DELETE=true to allow create and update workflows while preventing accidental data loss. Only delete operations are disabled.
Use cases:
Production environments where documents should not be deleted
Protecting against accidental deletions
Safe content editing workflows
Disabled tools:
delete_document, delete_collection
batch_delete_documents
Important: OUTLINE_READ_ONLY=true takes precedence over OUTLINE_DISABLE_DELETE. If both are set, the server operates in read-only mode.
Prerequisites: Install
uvwithpip install uvor from astral.sh/uv
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (or %APPDATA%\Claude\claude_desktop_config.json on Windows):
{
"mcpServers": {
"mcp-outline": {
"command": "uvx",
"args": ["mcp-outline"],
"env": {
"OUTLINE_API_KEY": "<YOUR_API_KEY>",
"OUTLINE_API_URL": "<YOUR_OUTLINE_URL>" // Optional
}
}
}
}Go to Settings → MCP and click Add Server:
{
"mcp-outline": {
"command": "uvx",
"args": ["mcp-outline"],
"env": {
"OUTLINE_API_KEY": "<YOUR_API_KEY>",
"OUTLINE_API_URL": "<YOUR_OUTLINE_URL>" // Optional
}
}
}Create a .vscode/mcp.json file in your workspace with the following configuration:
{
"servers": {
"mcp-outline": {
"type": "stdio",
"command": "uvx",
"args": ["mcp-outline"],
"env": {
"OUTLINE_API_KEY": "<YOUR_API_KEY>"
}
}
}
}For self-hosted Outline instances, add OUTLINE_API_URL to the env object.
Optional: Use input variables for sensitive credentials:
{
"inputs": [
{
"type": "promptString",
"id": "outline-api-key",
"description": "Outline API Key",
"password": true
}
],
"servers": {
"mcp-outline": {
"type": "stdio",
"command": "uvx",
"args": ["mcp-outline"],
"env": {
"OUTLINE_API_KEY": "${input:outline-api-key}"
}
}
}
}VS Code will automatically discover and load MCP servers from this configuration file. For more details, see the official VS Code MCP documentation.
In Cline extension settings, add to MCP servers:
{
"mcp-outline": {
"command": "uvx",
"args": ["mcp-outline"],
"env": {
"OUTLINE_API_KEY": "<YOUR_API_KEY>",
"OUTLINE_API_URL": "<YOUR_OUTLINE_URL>" // Optional
}
}
}If you prefer to use pip instead:
pip install mcp-outlineThen in your client config, replace "command": "uvx" with "command": "mcp-outline" and remove the "args" line:
{
"mcp-outline": {
"command": "mcp-outline",
"env": {
"OUTLINE_API_KEY": "<YOUR_API_KEY>",
"OUTLINE_API_URL": "<YOUR_OUTLINE_URL>" // Optional
}
}
}For remote access or Docker containers, use HTTP transport. This runs the MCP server on port 3000:
docker run -p 3000:3000 \
-e OUTLINE_API_KEY=<YOUR_API_KEY> \
-e MCP_TRANSPORT=streamable-http \
ghcr.io/vortiago/mcp-outline:latestThen connect from client:
{
"mcp-outline": {
"url": "http://localhost:3000/mcp"
}
}Note: OUTLINE_API_URL should point to where your Outline instance is running, not localhost:3000.
Note: Tool availability depends on your Access Control settings. Some tools are disabled in read-only mode or when delete operations are restricted.
search_documents(query, collection_id?, limit?, offset?) - Search documents by keywords with pagination
list_collections() - List all collections
get_collection_structure(collection_id) - Get document hierarchy within a collection
get_document_id_from_title(query, collection_id?) - Find document ID by title search
read_document(document_id) - Get document content
export_document(document_id) - Export document as markdown
create_document(title, collection_id, text?, parent_document_id?, publish?) - Create new document
update_document(document_id, title?, text?, append?) - Update document (append mode available)
move_document(document_id, collection_id?, parent_document_id?) - Move document to different collection or parent
archive_document(document_id) - Archive document
unarchive_document(document_id) - Restore document from archive
delete_document(document_id, permanent?) - Delete document (or move to trash)
restore_document(document_id) - Restore document from trash
list_archived_documents() - List all archived documents
list_trash() - List all documents in trash
add_comment(document_id, text, parent_comment_id?) - Add comment to document (supports threaded replies)
list_document_comments(document_id, include_anchor_text?, limit?, offset?) - View document comments with pagination
get_comment(comment_id, include_anchor_text?) - Get specific comment details
get_document_backlinks(document_id) - Find documents that link to this document
create_collection(name, description?, color?) - Create new collection
update_collection(collection_id, name?, description?, color?) - Update collection properties
delete_collection(collection_id) - Delete collection
export_collection(collection_id, format?) - Export collection (default: outline-markdown)
export_all_collections(format?) - Export all collections
batch_create_documents(documents) - Create multiple documents at once
batch_update_documents(updates) - Update multiple documents at once
batch_move_documents(document_ids, collection_id?, parent_document_id?) - Move multiple documents
batch_archive_documents(document_ids) - Archive multiple documents
batch_delete_documents(document_ids, permanent?) - Delete multiple documents
ask_ai_about_documents(question, collection_id?, document_id?) - Ask natural language questions about your documents
outline://collection/{id} - Collection metadata (name, description, color, document count)
outline://collection/{id}/tree - Hierarchical document tree structure
outline://collection/{id}/documents - Flat list of documents in collection
outline://document/{id} - Full document content (markdown)
outline://document/{id}/backlinks - Documents that link to this document
# Generate configuration
cp config/outline.env.example config/outline.env
openssl rand -hex 32 > /tmp/secret_key && openssl rand -hex 32 > /tmp/utils_secret
# Update config/outline.env with generated secrets
# Start all services
docker compose up -d
# Create API key: http://localhost:3030 → Settings → API Keys
# Add to .env: OUTLINE_API_KEY=<token>git clone https://github.com/Vortiago/mcp-outline.git
cd mcp-outline
uv pip install -e ".[dev]"# Run tests
uv run pytest tests/
# Format code
uv run ruff format .
# Type check
uv run pyright src/
# Lint
uv run ruff check .uv run mcp-outlineUse the MCP Inspector to test the server tools visually via an interactive UI.
For local development (with stdio):
npx @modelcontextprotocol/inspector -e OUTLINE_API_KEY=<your-key> -e OUTLINE_API_URL=<your-url> uv run python -m mcp_outlineFor Docker Compose (with HTTP):
npx @modelcontextprotocol/inspector http://localhost:3000
Rate Limiting: Automatically handled via header tracking (RateLimit-Remaining, RateLimit-Reset) with exponential backoff retry (up to 3 attempts). No configuration needed.
Transport Modes:
stdio (default): Direct process communication
sse: HTTP Server-Sent Events (use for web clients)
streamable-http: Streamable HTTP transport
Connection Pooling: Shared httpx connection pool across instances (configurable: OUTLINE_MAX_CONNECTIONS=100, OUTLINE_MAX_KEEPALIVE=20)
Check your API credentials:
# Test your API key
curl -H "Authorization: Bearer YOUR_API_KEY" YOUR_OUTLINE_URL/api/auth.infoCommon issues:
Verify OUTLINE_API_KEY is set correctly in your MCP client configuration
Check OUTLINE_API_URL points to your Outline instance (default: https://app.getoutline.com/api)
For self-hosted Outline, ensure the URL ends with /api
Verify your API key hasn't expired or been revoked
Read-only mode enabled? Check if OUTLINE_READ_ONLY=true is disabling write tools
Delete operations disabled? Check if OUTLINE_DISABLE_DELETE=true is hiding delete tools
AI tools missing? Check if OUTLINE_DISABLE_AI_TOOLS=true is disabling AI features
Restart your MCP client after changing environment variables
The server automatically handles rate limiting with retry logic. If you see persistent rate limit errors:
Reduce concurrent operations
Check if multiple clients are using the same API key
Contact Outline support if limits are too restrictive for your use case
Container won't start:
Ensure OUTLINE_API_KEY is set: docker run -e OUTLINE_API_KEY=your_key ...
Check logs: docker logs <container-id>
Can't connect from client:
Use 0.0.0.0 for MCP_HOST: -e MCP_HOST=0.0.0.0
Verify port mapping: -p 3000:3000
Check transport mode: -e MCP_TRANSPORT=streamable-http
Contributions welcome! See CONTRIBUTING.md for setup instructions.
This project is licensed under the MIT License - see the LICENSE file for details.
Built with MCP Python SDK
Uses Outline API for document management
Adds a comment to a document or replies to an existing comment.
Use this tool when you need to:
Provide feedback on document content
Ask questions about specific information
Reply to another user's comment
Collaborate with others on document development
Args: document_id: The document to comment on text: The comment text (supports markdown) parent_comment_id: Optional ID of a parent comment (for replies)
Returns: Result message with the new comment ID
Inputs: document_id (required), text (required), parent_comment_id. Returns: result
Archives a document to remove it from active use while preserving it.
IMPORTANT: Archived documents are removed from collections but remain searchable in the system. They won't appear in normal collection views but can still be found through search or the archive list.
Use this tool when you need to:
Remove outdated or inactive documents from view
Clean up collections while preserving document history
Preserve documents that are no longer relevant
Temporarily hide documents without deleting them
Args: document_id: The document ID to archive
Returns: Result message confirming archival
Inputs: document_id (required). Returns: result
Queries document content using natural language questions.
Use this tool when you need to:
Find specific information across multiple documents
Get direct answers to questions about document content
Extract insights from your knowledge base
Answer questions like "What is our vacation policy?"
Answer "How do we onboard new clients?" and similar queries
Args: question: The natural language question to ask collection_id: Optional collection to limit the search to document_id: Optional document to limit the search to
Returns: AI-generated answer based on document content with sources
Inputs: question (required), collection_id, document_id. Returns: result
Archives multiple documents in a single batch operation.
This tool processes each document sequentially, continuing even if individual operations fail. Rate limiting is handled automatically by the Outline client.
IMPORTANT: Archived documents are removed from collections but remain searchable. They won't appear in normal collection views but can still be found through search or the archive list.
Use this tool when you need to:
Archive multiple outdated documents at once
Clean up collections in bulk
Batch hide documents without deleting them
Recommended batch size: 10-50 documents per operation
Args: document_ids: List of document IDs to archive
Returns: Summary of batch operation with success/failure details
Inputs: document_ids (required). Returns: result
Creates multiple documents in a single batch operation.
This tool processes each creation sequentially, continuing even if individual operations fail. Rate limiting is handled automatically.
Each document dictionary should contain:
title (required): Document title
collection_id (required): Collection ID to create in
text (optional): Markdown content
parent_document_id (optional): Parent document for nesting
publish (optional): Whether to publish immediately (default: True)
Use this tool when you need to:
Create multiple documents at once
Bulk import content into collections
Set up document structures efficiently
Note: For Mermaid diagrams, use mermaidjs (not mermaid)
as the code fence language identifier for proper rendering.
Recommended batch size: 10-50 documents per operation
Args: documents: List of document specifications, each containing title, collection_id, and optional text, parent_document_id, and publish fields
Returns: Summary of batch operation with created document IDs and success/failure details
Inputs: documents (required). Returns: result
Deletes multiple documents, moving them to trash or permanently.
This tool processes each document sequentially, continuing even if individual operations fail. Rate limiting is handled automatically.
IMPORTANT: When permanent=False (the default), documents are moved to trash and retained for 30 days. Setting permanent=True bypasses trash and immediately deletes documents without recovery option.
Use this tool when you need to:
Remove multiple unwanted documents at once
Clean up workspace in bulk
Permanently delete sensitive information (with permanent=True)
Recommended batch size: 10-50 documents per operation
Args: document_ids: List of document IDs to delete permanent: If True, permanently deletes without recovery option
Returns: Summary of batch operation with success/failure details
Inputs: document_ids (required), permanent. Returns: result
Moves multiple documents to a different collection or parent.
This tool processes each document sequentially, continuing even if individual operations fail. Rate limiting is handled automatically.
IMPORTANT: When moving documents that have child documents, all children will move along with them, maintaining hierarchical structure. You must specify either collection_id or parent_document_id (or both).
Use this tool when you need to:
Reorganize multiple documents at once
Move documents between collections in bulk
Restructure document hierarchies efficiently
Recommended batch size: 10-50 documents per operation
Args: document_ids: List of document IDs to move collection_id: Target collection ID (optional) parent_document_id: Target parent document ID (optional)
Returns: Summary of batch operation with success/failure details
Inputs: document_ids (required), collection_id, parent_document_id. Returns: result
Updates multiple documents with different changes.
This tool processes each update sequentially, continuing even if individual operations fail. Rate limiting is handled automatically.
Each update dictionary should contain:
id (required): Document ID to update
title (optional): New title
text (optional): New content
append (optional): If True, appends text instead of replacing
Use this tool when you need to:
Update multiple documents with different changes
Batch edit document titles or content
Append content to multiple documents
Note: For Mermaid diagrams, use mermaidjs (not mermaid)
as the code fence language identifier for proper rendering.
Recommended batch size: 10-50 documents per operation
Args: updates: List of update specifications, each containing id and optional title, text, and append fields
Returns: Summary of batch operation with success/failure details
Inputs: updates (required). Returns: result
Creates a new collection for organizing documents.
Use this tool when you need to:
Create a new section or category for documents
Set up a workspace for a new project or team
Organize content by department or topic
Establish a separate space for related documents
Args: name: Name for the collection description: Optional description of the collection's purpose color: Optional hex color code for visual identification (e.g. #FF0000)
Returns: Result message with the new collection ID
Inputs: name (required), description, color. Returns: result
Creates a new document in a specified collection.
Use this tool when you need to:
Add new content to a knowledge base
Create documentation, guides, or notes
Add a child document to an existing parent
Start a new document thread or topic
Note: For Mermaid diagrams, use mermaidjs (not mermaid)
as the code fence language identifier for proper rendering.
Args: title: The document title collection_id: The collection ID to create the document in text: Optional markdown content for the document parent_document_id: Optional parent document ID for nesting publish: Whether to publish the document immediately (True) or save as draft (False)
Returns: Result message with the new document ID
Inputs: title (required), collection_id (required), text, parent_document_id, +1 more. Returns: result
Permanently removes a collection and all its documents.
Use this tool when you need to:
Remove an entire section of content
Delete obsolete project collections
Remove collections that are no longer needed
Clean up workspace organization
WARNING: This action cannot be undone and will delete all documents within the collection.
Args: collection_id: The collection ID to delete
Returns: Result message confirming deletion
Inputs: collection_id (required). Returns: result
Moves a document to trash or permanently deletes it.
IMPORTANT: When permanent=False (the default), documents are moved to trash and retained for 30 days before being permanently deleted. During this period, they can be restored using the restore_document tool. Setting permanent=True bypasses the trash and immediately deletes the document without any recovery option.
Use this tool when you need to:
Remove unwanted or unnecessary documents
Delete obsolete content
Clean up workspace by removing documents
Permanently remove sensitive information (with permanent=True)
Args: document_id: The document ID to delete permanent: If True, permanently deletes the document without recovery option
Returns: Result message confirming deletion
Inputs: document_id (required), permanent. Returns: result
Exports the entire workspace content to a downloadable file.
IMPORTANT: This tool starts an asynchronous export operation which may take time to complete, especially for large workspaces. The function returns information about the operation, including its status. When the operation is complete, the file can be downloaded or accessed via Outline's UI. The export includes all collections, documents, and their hierarchies in the specified format.
Use this tool when you need to:
Create a complete backup of all workspace content
Migrate content to another system
Archive all workspace documents
Get a comprehensive export of knowledge base
Args: format: Export format ("outline-markdown", "json", or "html")
Returns: Information about the export operation and how to access the file
Inputs: format. Returns: result
Exports all documents in a collection to a downloadable file.
IMPORTANT: This tool starts an asynchronous export operation which may take time to complete. The function returns information about the operation, including its status. When the operation is complete, the file can be downloaded or accessed via Outline's UI. The export preserves the document hierarchy and includes all document content and structure in the specified format.
Use this tool when you need to:
Create a backup of collection content
Share collection content outside of Outline
Convert collection content to other formats
Archive collection content for offline use
Args: collection_id: The collection ID to export format: Export format ("outline-markdown", "json", or "html")
Returns: Information about the export operation and how to access the file
Inputs: collection_id (required), format. Returns: result
Exports a document as plain markdown text.
Use this tool when you need to:
Get clean markdown content without formatting
Extract document content for external use
Process document content in another application
Share document content outside Outline
Args: document_id: The document ID to export
Returns: Document content in markdown format without additional formatting
Inputs: document_id (required). Returns: result
Retrieves the hierarchical document structure of a collection.
Use this tool when you need to:
Understand how documents are organized in a collection
Find document IDs within a specific collection
See the parent-child relationships between documents
Get an overview of a collection's content structure
Args: collection_id: The collection ID to examine
Returns: Formatted string showing the hierarchical structure of documents
Inputs: collection_id (required). Returns: result
Retrieves a specific comment by its ID.
Use this tool when you need to:
View details of a specific comment
Reference or quote a particular comment
Check comment content and metadata
Find a comment mentioned elsewhere
Args: comment_id: The comment ID to retrieve include_anchor_text: Whether to include the document text that the comment refers to
Returns: Formatted string with the comment content and metadata
Inputs: comment_id (required), include_anchor_text. Returns: result
Finds all documents that link to a specific document.
Use this tool when you need to:
Discover references to a document across the workspace
Identify dependencies between documents
Find documents related to a specific document
Understand document relationships and connections
Args: document_id: The document ID to find backlinks for
Returns: Formatted string listing all documents that link to the specified document
Inputs: document_id (required). Returns: result
Locates a document ID by searching for its title.
IMPORTANT: This tool first checks for exact title matches (case-insensitive). If none are found, it returns the best partial match instead. This is useful when you're not sure of the exact title but need to reference a document in other operations. Results are more accurate when you provide more of the actual title in your query.
Use this tool when you need to:
Find a document's ID when you only know its title
Get the document ID for use in other operations
Verify if a document with a specific title exists
Find the best matching document if exact title is unknown
Args: query: Title to search for (can be exact or partial) collection_id: Optional collection to limit the search to
Returns: Document ID if found, or best match information
Inputs: query (required), collection_id. Returns: result
Displays all documents that have been archived.
Use this tool when you need to:
Find specific archived documents
Review what documents have been archived
Identify documents for possible unarchiving
Check archive status of workspace content
Returns: Formatted string containing list of archived documents
Inputs: no named parameters. Returns: result
Retrieves and displays all available collections in the workspace.
Use this tool when you need to:
See what collections exist in the workspace
Get collection IDs for other operations
Explore the organization of the knowledge base
Find a specific collection by name
Returns: Formatted string containing collection names, IDs, and descriptions
Inputs: no named parameters. Returns: result
Retrieves comments on a specific document with pagination support.
IMPORTANT: By default, this returns up to 25 comments at a time. If there are more than 25 comments on the document, you'll need to make multiple calls with different offset values to get all comments. The response will indicate if there are more comments available.
Use this tool when you need to:
Review feedback and discussions on a document
See all comments from different users
Find specific comments or questions
Track collaboration and input on documents
Args: document_id: The document ID to get comments from include_anchor_text: Whether to include the document text that comments refer to limit: Maximum number of comments to return (default: 25) offset: Number of comments to skip for pagination (default: 0)
Returns: Formatted string containing comments with author, date, and optional anchor text
Inputs: document_id (required), include_anchor_text, limit, offset. Returns: result
Displays all documents currently in the trash.
Use this tool when you need to:
Find deleted documents that can be restored
Review what documents are pending permanent deletion
Identify documents to restore from trash
Verify if specific documents were deleted
Returns: Formatted string containing list of documents in trash
Inputs: no named parameters. Returns: result
Relocates a document to a different collection or parent document.
IMPORTANT: When moving a document that has child documents (nested documents), all child documents will move along with it, maintaining their hierarchical structure. You must specify either collection_id or parent_document_id (or both).
Use this tool when you need to:
Reorganize your document hierarchy
Move a document to a more relevant collection
Change a document's parent document
Restructure content organization
Args: document_id: The document ID to move collection_id: Target collection ID (if moving between collections) parent_document_id: Optional parent document ID (for nesting)
Returns: Result message confirming the move operation
Inputs: document_id (required), collection_id, parent_document_id. Returns: result
Retrieves and displays the full content of a document.
Use this tool when you need to:
Access the complete content of a specific document
Review document information in detail
Quote or reference document content
Analyze document contents
Args: document_id: The document ID to retrieve
Returns: Formatted string containing the document title and content
Inputs: document_id (required). Returns: result
Recovers a document from the trash back to active status.
Use this tool when you need to:
Retrieve accidentally deleted documents
Restore documents from trash to active use
Recover documents deleted within the last 30 days
Access content that was previously trashed
Args: document_id: The document ID to restore
Returns: Result message confirming restoration
Inputs: document_id (required). Returns: result
Searches for documents using keywords or phrases across your knowledge base.
IMPORTANT: The search performs full-text search across all document content and titles. Results are ranked by relevance, with exact matches and title matches typically ranked higher. The search will return snippets of content (context) where the search terms appear in the document. You can limit the search to a specific collection by providing the collection_id.
PAGINATION: By default, returns up to 25 results at a time. If more results exist, use the 'offset' parameter to fetch additional pages. For example, use offset=25 to get results 26-50, offset=50 for 51-75, etc.
Use this tool when you need to:
Find documents containing specific terms or topics
Locate information across multiple documents
Search within a specific collection using collection_id
Discover content based on keywords
Browse through large result sets using limit and offset
Args: query: Search terms (e.g., "vacation policy" or "project plan") collection_id: Optional collection to limit the search to limit: Maximum results to return (default: 25, max: 100) offset: Number of results to skip for pagination (default: 0)
Returns: Formatted string containing search results with document titles, contexts, and pagination information
Inputs: query (required), collection_id, limit, offset. Returns: result
Restores a previously archived document to active status.
Use this tool when you need to:
Restore archived documents to active use
Access or reference previously archived content
Make archived content visible in collections again
Update and reuse archived documents
Args: document_id: The document ID to unarchive
Returns: Result message confirming restoration
Inputs: document_id (required). Returns: result
Modifies an existing collection's properties.
Use this tool when you need to:
Rename a collection
Update a collection's description
Change a collection's color coding
Refresh collection metadata
Args: collection_id: The collection ID to update name: Optional new name for the collection description: Optional new description color: Optional new hex color code (e.g. #FF0000)
Returns: Result message confirming update
Inputs: collection_id (required), name, description, color. Returns: result
Modifies an existing document's title or content.
IMPORTANT: This tool replaces the document content rather than just adding to it. To update a document with changed data, you need to first read the document, add your changes to the content, and then send the complete document with your changes.
Use this tool when you need to:
Edit or update document content
Change a document's title
Append new content to an existing document
Fix errors or add information to documents
Note: For Mermaid diagrams, use mermaidjs (not mermaid)
as the code fence language identifier for proper rendering.
Args: document_id: The document ID to update title: New title (if None, keeps existing title) text: New content (if None, keeps existing content) append: If True, adds text to the end of document instead of replacing
Returns: Result message confirming update
Inputs: document_id (required), title, text, append. Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 30 tools
The tools cover distinct areas like documents, collections, comments, search, and batch operations, with clear boundaries. However, the presence of multiple batch tools and the overlap between archive/unarchive and delete/restore could cause slight confusion.
All tool names follow a consistent snake_case verb_noun pattern (e.g., add_comment, create_collection, search_documents). Even complex names like ask_ai_about_documents adhere to the pattern, ensuring predictability.
With 30 tools, the server covers a comprehensive range of operations for a knowledge base application. While slightly above the typical sweet spot, each tool serves a clear purpose and the count is justified by the feature set.
The tool set provides full CRUD for documents and collections, plus archiving, moving, commenting, searching, exporting, and batch operations. The inclusion of AI query and backlink detection adds advanced functionality, leaving no obvious gaps for document management.
A Model Context Protocol server for Wix AI tools
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Model Context Protocol server for todo.vu task management and time tracking.