Outline MCP Server

•

A Model Context Protocol (MCP) server that provides tools for interacting with Outline's API, enabling AI agents to manage documents, collections, and other entities programmatically through the Outline knowledge base platform.

Quick Installation

Cursor

One click install in Cursor:

Claude Desktop

You can now download a Claude Desktop extension from the releases page for quick and easy setup (just double click it).

Claude Code

Add the Outline MCP server to Claude Code with:

claude mcp add outline -s user -t stdio -e OUTLINE_API_KEY=... -- npx -y --package=outline-mcp-server@latest -c outline-mcp-server-stdio

Other Methods

This MCP server can be added to just about any agent with an appropriate command defining npx and env vars. Read below for more info on how to run the server manually. Jump to Running →

Features

• Document Management

  • ✅ Create new documents with customizable properties
  • ✅ Get document details
  • ✅ Update existing documents
  • ✅ Delete documents
  • ✅ List documents
  • ✅ Search documents
  • ✅ Ask natural language questions about documents
  • ✅ Create templates from existing documents
  • ✅ Move documents to different collections or locations
  • ✅ Archive documents

• Collection Management

  • ✅ Get collection details
  • ✅ List collections
  • ✅ Create and update collections

• Comment Management

  • ✅ Create comments on documents
  • ✅ Update existing comments
  • ✅ Delete comments

• User Management

  • ✅ List and filter users

Quick Start

Prerequisites

• Node.js (v24 or higher)
• Outline account with API access
• Outline API key with appropriate permissions
• Note: if you need to use the AI-powered ask feature, you must enable the "AI Answers" feature in your Outline Workspace settings

Running

outline-mcp-server supports the latest streamable-http protocol, the deprecated sse protocol, and good ole fashioned stdio.

# S-HTTP/SSE servers (with optional env var)
OUTLINE_API_KEY=... npx -y outline-mcp-server@latest

# S-HTTP/SSE servers (without env var, use headers for auth)
npx -y outline-mcp-server@latest

# STDIO (requires env var)
OUTLINE_API_KEY=... npx -y --package=outline-mcp-server@latest -c outline-mcp-server-stdio

When running HTTP/SSE servers without an environment variable, you'll need to provide the API key in your request headers. The server will display available authentication methods on startup.

Cursor (mcp.json)

Add the following MCP definition to your configuration:

{
  "outline": {
    "command": "npx",
    "args": ["-y", "outline-mcp-server-stdio@latest"],
    "env": {
      "OUTLINE_API_KEY": "<REPLACE_ME>",
      "OUTLINE_API_URL": "https://app.getoutline.com/api",
      "OUTLINE_MCP_PORT": "6060",
      "OUTLINE_MCP_HOST": "127.0.0.1"
    }
  }
}

Authentication

The Outline MCP server supports two authentication methods:

1. Environment Variable (Required for stdio mode): Set OUTLINE_API_KEY as an environment variable
2. Request Headers (HTTP/SSE modes): Provide the API key in request headers

For stdio mode, the API key environment variable is required and validated on startup.

For HTTP/SSE modes, you have two options:

• Set OUTLINE_API_KEY as an environment variable (fallback method)
• Provide API key in request headers (recommended for per-request authentication)

Header-based Authentication

When using HTTP/SSE endpoints, you can provide the API key using any of these headers:

• x-outline-api-key: your_api_key_here
• outline-api-key: your_api_key_here
• authorization: Bearer your_api_key_here

If no header is provided, the server will fall back to the OUTLINE_API_KEY environment variable. If neither is available, the request will fail with an authentication error.

Env vars

• OUTLINE_API_KEY (required for stdio, optional for HTTP/SSE): your API key for outline
• OUTLINE_API_URL (optional): Alternative URL for your outline API (if using an alt domain/self-hosting)
• OUTLINE_MCP_PORT (optional): Specify the port on which the server will run (default: 6060)
• OUTLINE_MCP_HOST (optional): Host/IP to bind the server to (default: 127.0.0.1). Use 0.0.0.0 to bind to all network interfaces

Usage

Once installed, you can use the MCP server with AI assistants that support the Model Context Protocol, such as Claude via Cursor.

Example queries your AI assistant can now handle:

• "List all the documents in my Outline workspace"
• "Create a new document in the 'Product' collection"
• "Find all documents related to a specific topic"
• "Ask a natural language question about your documents"
• "Create a template from an existing document"
• "Update the content of a document"
• "Add a comment to a document"

Docker Usage

You can run the Outline MCP Server using Docker or Docker Compose for easy deployment.

1. Prepare your .env file

Copy .env.example to .env and fill in your Outline API key:

cp .env.example .env
# Edit .env and set OUTLINE_API_KEY=your_outline_api_key_here

2. Build and run with Docker Compose (recommended)

docker-compose up --build

• The server will be available on port 6060 by default.
• Environment variables are loaded from your .env file.

3. Build and run manually with Docker

docker build -t outline-mcp-server .
docker run --env-file .env -p 6060:6060 outline-mcp-server

• You can override environment variables at runtime with -e flags if needed.

4. Customizing

• To change the API URL, set OUTLINE_API_URL in your .env file or as an environment variable.
• To change the port or host, set OUTLINE_MCP_PORT and OUTLINE_MCP_HOST in your .env file or as environment variables.
• For more advanced setups, edit docker-compose.yml as needed.

Development

# Clone this repository
git clone https://github.com/mmmeff/outline-mcp.git
cd outline-mcp

# Install dependencies
npm install

Create a .env file with your Outline API key:

OUTLINE_API_KEY=your_outline_api_key_here

# Optional -------
# OUTLINE_API_URL=https://your-outline-instance.com/api # defaults to https://app.getoutline.com/api
# OUTLINE_MCP_PORT=9001

# Builds/watches the project alongside running @modelcontextprotocol/inspector
npm run dev

Contributing

This project uses semantic-release for automated versioning and package publishing. Please follow the Conventional Commits specification for your commit messages to ensure proper versioning.

See CONTRIBUTING.md for detailed guidelines on how to contribute to this project.

Release Process

Releases are fully automated using semantic-release and GitHub Actions. When commits are pushed to the master branch, the following happens:

1. The CI pipeline runs tests and builds the package
2. semantic-release analyzes commit messages to determine the next version number
3. A new version is automatically published to npm
4. A GitHub release is created with auto-generated release notes
5. The CHANGELOG.md file is updated

No manual version bumping or release creation is needed.

License

MIT