# Outline Mcp Server

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

- **Type:** MCP server
- **Install:** `agentstack add mcp-mmmeff-outline-mcp-server`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [mmmeff](https://agentstack.voostack.com/s/mmmeff)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [mmmeff](https://github.com/mmmeff)
- **Source:** https://github.com/mmmeff/outline-mcp-server

## Install

```sh
agentstack add mcp-mmmeff-outline-mcp-server
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

> [!WARNING]
> 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.

---

# Outline MCP Server

 • 

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.

## Quick Installation

### Cursor

One click install in Cursor:

[](https://cursor.com/install-mcp?name=outline&config=eyJjb21tYW5kIjoibnB4IC15IC0tcGFja2FnZT1vdXRsaW5lLW1jcC1zZXJ2ZXJAbGF0ZXN0IC1jIG91dGxpbmUtbWNwLXNlcnZlci1zdGRpbyIsImVudiI6eyJPVVRMSU5FX0FQSV9LRVkiOiI8UkVQTEFDRV9NRT4iLCJPVVRMSU5FX0FQSV9VUkwiOiJodHRwczovL2FwcC5nZXRvdXRsaW5lLmNvbS9hcGkifX0%3D)

### 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:

```bash
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 →](#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**
  - ✅ List comments for documents and collections
  - ✅ 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.

```bash
# 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:

```json
{
  "outline": {
    "command": "npx",
    "args": ["-y", "--package=outline-mcp-server@latest", "-c", "outline-mcp-server-stdio"],
    "env": {
      "OUTLINE_API_KEY": "",
      "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:

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

### 2. Build and run with Docker Compose (recommended)

```bash
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

```bash
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

```bash
# 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
```

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

## Contributing

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.

See [CONTRIBUTING.md](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

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [mmmeff](https://github.com/mmmeff)
- **Source:** [mmmeff/outline-mcp-server](https://github.com/mmmeff/outline-mcp-server)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-mmmeff-outline-mcp-server
- Seller: https://agentstack.voostack.com/s/mmmeff
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.