Skip to content
Back to search

outline-mcp-server

It's an MCP server... for Outline (the documentation platform!)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mmmeff--outline-mcp-server/badge.svg)](/listings/mmmeff--outline-mcp-server)

HTML

<a href="/listings/mmmeff--outline-mcp-server"><img src="/api/listings/mmmeff--outline-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Cursor

One click install in Cursor:

Claude Desktop

You can now download a Claude Desktop extension from the [releases page](https://github.com/mmmeff/outline-mcp/releases) 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 &rarr;](#running)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 240 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. > [!WARNING]
  2. > This project is no longer maintained as Outline has launched its own [official MCP server](https://docs.getoutline.com/s/guide/doc/mcp-6j9jtENNKL) with OAuth support. You should use that.
  3. ---
  4. # Outline MCP Server
  5. ![npm](https://img.shields.io/npm/v/outline-mcp-server) • ![downloads](https://img.shields.io/npm/dy/outline-mcp-server)
  6. A Model Context Protocol (MCP) server that provides tools for interacting with [Outline](https://www.getoutline.com/)'s API, enabling AI agents to manage documents, collections, and other entities programmatically through the Outline knowledge base platform.
  7. ## Quick Installation
  8. ### Cursor
  9. One click install in Cursor:
  10. [![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/install-mcp?name=outline&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT1vdXRsaW5lLW1jcC1zZXJ2ZXJAbGF0ZXN0IC1jIG91dGxpbmUtbWNwLXNlcnZlci1zdGRpbyIsImVudiI6eyJPVVRMSU5FX0FQSV9LRVkiOiI8UkVQTEFDRV9NRT4iLCJPVVRMSU5FX0FQSV9VUkwiOiJodHRwczovL2FwcC5nZXRvdXRsaW5lLmNvbS9hcGkifX0%3D)
  11. ### Claude Desktop
  12. You can now download a Claude Desktop extension from the [releases page](https://github.com/mmmeff/outline-mcp/releases) for quick and easy setup (just double click it).
  13. ### Claude Code
  14. Add the Outline MCP server to Claude Code with:
  15. ```bash
  16. claude mcp add outline -s user -t stdio -e OUTLINE_API_KEY=... -- npx -y --package=outline-mcp-server@latest -c outline-mcp-server-stdio
  17. ```
  18. ### Other Methods
  19. 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.
  20. [Jump to Running &rarr;](#running)
  21. ## Features
  22. - **Document Management**
  23. - ✅ Create new documents with customizable properties
  24. - ✅ Get document details
  25. - ✅ Update existing documents
  26. - ✅ Delete documents
  27. - ✅ List documents
  28. - ✅ Search documents
  29. - ✅ Ask natural language questions about documents
  30. - ✅ Create templates from existing documents
  31. - ✅ Move documents to different collections or locations
  32. - ✅ Archive documents
  33. - **Collection Management**
  34. - ✅ Get collection details
  35. - ✅ List collections
  36. - ✅ Create and update collections
  37. - **Comment Management**
  38. - ✅ List comments for documents and collections
  39. - ✅ Create comments on documents
  40. - ✅ Update existing comments
  41. - ✅ Delete comments
  42. - **User Management**
  43. - ✅ List and filter users
  44. ## Quick Start
  45. ### Prerequisites
  46. - Node.js (v24 or higher)
  47. - Outline account with API access
  48. - Outline API key with appropriate permissions
  49. - Note: if you need to use the AI-powered ask feature, you must enable the "AI Answers" feature in your Outline Workspace settings
  50. ### Running
  51. `outline-mcp-server` supports the latest streamable-http protocol, the deprecated sse protocol, and good ole fashioned stdio.
  52. ```bash
  53. # S-HTTP/SSE servers (with optional env var)
  54. OUTLINE_API_KEY=... npx -y outline-mcp-server@latest
  55. # S-HTTP/SSE servers (without env var, use headers for auth)
  56. npx -y outline-mcp-server@latest
  57. # STDIO (requires env var)
  58. OUTLINE_API_KEY=... npx -y --package=outline-mcp-server@latest -c outline-mcp-server-stdio
  59. ```
  60. 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.
  61. ### Cursor (mcp.json)
  62. Add the following MCP definition to your configuration:
  63. ```json
  64. {
  65. "outline": {
  66. "command": "npx",
  67. "args": ["-y", "--package=outline-mcp-server@latest", "-c", "outline-mcp-server-stdio"],
  68. "env": {
  69. "OUTLINE_API_KEY": "<REPLACE_ME>",
  70. "OUTLINE_API_URL": "https://app.getoutline.com/api",
  71. "OUTLINE_MCP_PORT": "6060",
  72. "OUTLINE_MCP_HOST": "127.0.0.1"
  73. }
  74. }
  75. }
  76. ```
  77. ### Authentication
  78. The Outline MCP server supports two authentication methods:
  79. 1. **Environment Variable (Required for stdio mode)**: Set `OUTLINE_API_KEY` as an environment variable
  80. 2. **Request Headers (HTTP/SSE modes)**: Provide the API key in request headers
  81. For **stdio mode**, the API key environment variable is required and validated on startup.
  82. For **HTTP/SSE modes**, you have two options:
  83. - Set `OUTLINE_API_KEY` as an environment variable (fallback method)
  84. - Provide API key in request headers (recommended for per-request authentication)
  85. #### Header-based Authentication
  86. When using HTTP/SSE endpoints, you can provide the API key using any of these headers:
  87. - `x-outline-api-key: your_api_key_here`
  88. - `outline-api-key: your_api_key_here`
  89. - `authorization: Bearer your_api_key_here`
  90. 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.
  91. ### Env vars
  92. - `OUTLINE_API_KEY` (_required for stdio, optional for HTTP/SSE_): your API key for outline
  93. - `OUTLINE_API_URL` (_optional_): Alternative URL for your outline API (if using an alt domain/self-hosting)
  94. - `OUTLINE_MCP_PORT` (_optional_): Specify the port on which the server will run (default: 6060)
  95. - `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
  96. ### Usage
  97. Once installed, you can use the MCP server with AI assistants that support the Model Context Protocol, such as Claude via Cursor.
  98. Example queries your AI assistant can now handle:
  99. - "List all the documents in my Outline workspace"
  100. - "Create a new document in the 'Product' collection"
  101. - "Find all documents related to a specific topic"
  102. - "Ask a natural language question about your documents"
  103. - "Create a template from an existing document"
  104. - "Update the content of a document"
  105. - "Add a comment to a document"
  106. ## Docker Usage
  107. You can run the Outline MCP Server using Docker or Docker Compose for easy deployment.
  108. ### 1. Prepare your `.env` file
  109. Copy `.env.example` to `.env` and fill in your Outline API key:
  110. ```bash
  111. cp .env.example .env
  112. # Edit .env and set OUTLINE_API_KEY=your_outline_api_key_here
  113. ```
  114. ### 2. Build and run with Docker Compose (recommended)
  115. ```bash
  116. docker-compose up --build
  117. ```
  118. - The server will be available on port 6060 by default.
  119. - Environment variables are loaded from your `.env` file.
  120. ### 3. Build and run manually with Docker
  121. ```bash
  122. docker build -t outline-mcp-server .
  123. docker run --env-file .env -p 6060:6060 outline-mcp-server
  124. ```
  125. - You can override environment variables at runtime with `-e` flags if needed.
  126. ### 4. Customizing
  127. - To change the API URL, set `OUTLINE_API_URL` in your `.env` file or as an environment variable.
  128. - To change the port or host, set `OUTLINE_MCP_PORT` and `OUTLINE_MCP_HOST` in your `.env` file or as environment variables.
  129. - For more advanced setups, edit `docker-compose.yml` as needed.
  130. ---
  131. ## Development
  132. ```bash
  133. # Clone this repository
  134. git clone https://github.com/mmmeff/outline-mcp.git
  135. cd outline-mcp
  136. # Install dependencies
  137. npm install
  138. ```
  139. ### Create a `.env` file with your Outline API key:
  140. ```
  141. OUTLINE_API_KEY=your_outline_api_key_here
  142. # Optional -------
  143. # OUTLINE_API_URL=https://your-outline-instance.com/api # defaults to https://app.getoutline.com/api
  144. # OUTLINE_MCP_PORT=9001
  145. ```
  146. ```bash
  147. # Builds/watches the project alongside running @modelcontextprotocol/inspector
  148. npm run dev
  149. ```
  150. ## Contributing
  151. This project uses [semantic-release](https://semantic-release.gitbook.io/semantic-release/) for automated versioning and package publishing. Please follow the [Conventional Commits](https://www.conventionalcommits.org/) specification for your commit messages to ensure proper versioning.
  152. See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines on how to contribute to this project.
  153. ## Release Process
  154. Releases are fully automated using semantic-release and GitHub Actions. When commits are pushed to the `master` branch, the following happens:
  155. 1. The CI pipeline runs tests and builds the package
  156. 2. semantic-release analyzes commit messages to determine the next version number
  157. 3. A new version is automatically published to npm
  158. 4. A GitHub release is created with auto-generated release notes
  159. 5. The CHANGELOG.md file is updated
  160. No manual version bumping or release creation is needed.
  161. ## License
  162. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.