home / mcp / outline mcp server

Outline MCP Server

Allows AI agents to manage Outline documents, collections, comments, and users via MCP with HTTP or STDIO modes.

Installation

Add the following to your MCP client configuration file.

Configuration

{
  "mcpServers": {
    "mmmeff-outline-mcp-server": {
      "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_HOST": "127.0.0.1",
        "OUTLINE_MCP_PORT": "6060"
      }
    }
  }
}

You set up a Model Context Protocol (MCP) server to interact with Outline’s API, letting AI agents manage documents, collections, comments, and users within your Outline workspace. This provides programmatic access for tasks like listing documents, creating templates, adding comments, and filtering users, enabling automation and smarter workflows.

How to use

You connect an MCP client to the server and issue high-level actions that map to Outline operations. Typical patterns include listing documents, creating or updating documents in a specific collection, searching for documents by topic, asking natural language questions about documents, and creating templates from existing documents. You can also manage collections, comments, and users through the same MCP surface. Use these capabilities to drive automated AI assistants, workflow automations, or custom dashboards that read or modify your Outline knowledge base.

How to install

Prerequisites you need before installing: Node.js (version 20 or higher). An Outline account with API access and an API key that has the appropriate permissions for the actions you plan to perform. If you plan to use the AI-powered ask feature, ensure the AI Answers capability is enabled in your Outline workspace settings.

Install and run the MCP server using the recommended approach via npm/npx. You can run the server in two modes depending on your environment: HTTP/SSE (remote or cloud-ish) or STDIO (local process). The following commands show the two primary startup patterns.

# 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 can provide the API key in request headers. The server will display available authentication methods on startup.

If you plan to run the stdio mode, you must provide the API key via the environment variable. For HTTP/SSE, you have two options: set the API key as an environment variable or pass the API key in request headers for per-request authentication.

How to install

Cursor users can configure and run the MCP server by adding a configuration entry that points to the local stdio command and environment variables.

{ 
  "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"
    }
  }
}

Environment and authentication

Choose an authentication method that fits your deployment. For stdio mode, set OUTLINE_API_KEY as an environment variable. For HTTP/SSE modes, provide the API key in request headers (any of x-outline-api-key, outline-api-key, or authorization: Bearer). If a header is not supplied, the server will try the environment variable as a fallback.

Environment variables you may use include the API key, the API URL, and the MCP listener settings for port and host. These are useful when you want to run the server locally and expose it on a specific interface or port.

Docker and development workflow

If you prefer containerized deployment, you can run the MCP server with Docker or Docker Compose. Prepare an environment file containing your Outline API key and any optional settings, then start the container to expose the MCP port.

For development, you can clone the project, install dependencies, and run a dev server to iterate on changes.

Examples of common tasks

List all documents in your workspace, create a new document in a target collection, search for documents by topic, or generate a template from an existing document. You can also update a document’s content, move documents between collections, archive documents, or manage comments and users through the MCP interface.

Available tools

list_documents

Retrieve a list of documents in the workspace with optional filters and pagination.

get_document_details

Fetch detailed information for a single document by its ID.

create_document

Create a new document with specified properties and content.

update_document

Update properties or content of an existing document.

delete_document

Remove a document from the workspace.

search_documents

Query documents by keywords, topics, or metadata.

ask_document_question

Ask natural language questions about documents and get answers.

create_template_from_document

Generate a template from an existing document for reuse.

move_document

Move a document to a different collection or location.

archive_document

Archive a document to remove it from active results.

list_collections

List available collections in the workspace.

get_collection_details

Fetch details for a specific collection.

create_collection

Create a new collection with metadata and permissions.

update_collection

Update collection properties or settings.

delete_collection

Delete a collection.

create_comment

Add a comment to a document.

update_comment

Edit an existing comment.

delete_comment

Remove a comment from a document.

list_users

List and filter users in the Outline workspace.