OU
Search

Outline MCP Server: Document Search and Management

Manage and search Outline knowledge with an MCP server to read, create, edit documents, access collections, add comments, and handle backlinks.

View on GitHub
Quick Install
npx -y @Vortiago/mcp-outline

Overview

This MCP (Model Context Protocol) server integrates Outline — an open-source knowledge base — with LLMs and other agents by exposing Outline operations as programmatic tools. The server implements the MCP spec to let models request document reads, creates, edits, collection listings, comments, and backlink lookups as part of a tool-enabled conversation. That makes it straightforward to use an LLM to explore and modify a team’s Outline knowledge without having to embed credentials or call the Outline API directly from the model.

For developers, the server provides a lightweight adapter between Outline’s HTTP API and tools consumed by model-driven workflows. You can run it locally or in containerized environments, configure the Outline host and token via environment variables, and then register the MCP tools with your model execution environment so agents can reliably perform search-and-edit flows against your knowledge base.

Features

  • Exposes Outline operations as MCP-compatible tools for LLMs and agents
  • Read and search documents (full-text search and metadata)
  • Create and edit documents programmatically
  • List and inspect collections and their documents
  • Add and read comments on documents
  • Retrieve and follow backlink relationships between documents
  • Configurable via environment variables and suited for local or container deployment
  • Designed to be used with existing MCP-capable model runtimes

Installation / Configuration

Prerequisites: Node.js (16+ recommended), npm or yarn, Outline instance URL and API token.

  1. Clone the repository and install dependencies:
git clone https://github.com/Vortiago/mcp-outline.git
cd mcp-outline
npm install
# or
yarn
  1. Create an environment file (.env) with your Outline configuration:
OUTLINE_URL=https://outline.example.com
OUTLINE_TOKEN=sk_abcdefghijklmnopqrstuvwxyz
PORT=3000
MCP_HOST=0.0.0.0
MCP_PORT=3001
  1. Start the server in development:
npm run dev
# or
npm start
  1. Docker (optional): build and run the container
docker build -t mcp-outline .
docker run -e OUTLINE_URL="$OUTLINE_URL" -e OUTLINE_TOKEN="$OUTLINE_TOKEN" -p 3000:3000 mcp-outline

Notes:

  • The server requires a valid Outline API token with sufficient scope to read and write documents.
  • Configure network and secrets according to your security requirements when deploying to production.

Available Tools / Resources

The MCP server presents a set of tools that map to common Outline actions. These are the high-level capabilities you can expect to register with an MCP-capable model:

  • search_documents: Full-text and metadata search across Outline documents
  • get_document: Load a document by ID or slug (read content, metadata)
  • create_document: Create a new document under a collection or parent
  • edit_document: Update document title, text, or metadata
  • list_collections: Enumerate collections and basic info
  • add_comment: Post a comment to a document
  • get_comments: Retrieve comments for a document
  • get_backlinks: Retrieve documents that reference a given document

Resources:

  • GitHub repository: https://github.com/Vortiago/mcp-outline
  • Outline docs: https://www.getoutline.com/docs (reference for Outline API)
  • MCP spec: (refer to your MCP runtime docs for registration details)

API Reference (examples)

Below are example HTTP interactions you can use to exercise the server. Exact endpoints may vary; consult the repo for full route definitions.

Search documents

curl -X POST "http://localhost:3000/search" \
  -H "Content-Type: application/json" \
  -d '{"q":"database migration", "limit":10}'

Get a document

curl "http://localhost:3000/documents/:id"

Create a document

curl -X POST "http://localhost:3000/documents" \
  -H "Content-Type: application/json" \
  -d '{
    "title":"New Runbook",
    "text":"## Steps\n1. Do this\n2. Do that",
    "collectionId":"<collection-id>"
  }'

Add a comment

curl -X POST "http://localhost:3000/documents/:id/comments" \
  -H "Content-Type: application/json" \
  -d '{"text":"This needs an update for v2.0"}'

Get backlinks

curl "http://localhost:3000/documents/:id/backlinks"

Use Cases

  • Search-assisted knowledge retrieval
    • Integrate with an assistant that takes a user query, uses the server’s search_documents tool to surface relevant Outline pages, and composes a concise answer citing the documents.
  • Automated documentation maintenance
    • Run a scheduled agent that finds pages mentioning deprecated APIs (search), patches recommended updates (edit_document), and opens comments for human review (add_comment).
  • Onboarding agent
    • Provide a chat-based onboarding assistant that can fetch collection summaries (list_collections), present relevant docs (get_document), and create notes for new hires (create_document).
  • Backlink-driven navigation
    • Enable a model to use get_backlinks to trace relationships between architecture docs and create a synthesized overview of dependent systems.

Tips for Developers

  • Keep the Outline API token private; use secret management when deploying.
  • Limit agent permissions and use an allowlist to control which tools a model can invoke.
  • Test workflows locally (curl / Postman) before exposing the server to production agents.
  • Review the repository’s code and routes to match exact API path names and available parameters when integrating with your MCP runtime.

For implementation details and the authoritative route definitions, see the GitHub repository: https://github.com/Vortiago/mcp-outline.

Tags:search