Burn Mcp Server

by Fisher521

185 downloads

Not rated

GitHub

Description

# Burn — Personal Knowledge Base MCP Server [![npm version](https://img.shields.io/npm/v/burn-mcp-server.svg)](https://www.npmjs.com/package/burn-mcp-server) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) Your reading…

About

Details

Author: Fisher521
Downloads: 185
Categories: Productivity, Other, AI, Knowledge Base

- 26 tools for search, triage, collections, analysis, and auto‑feed
- 24‑hour reading inbox (Flame) that expires
- Spark (30‑day) and Vault (permanent) bookmark tiers
- Batch triage: move up to 20 bookmarks at once
- Auto‑feed: watch X users, RSS feeds, or YouTube channels
- Collection management with AI overview support

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Burn Mcp Server

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

From the repository

Obtain a token from the Burn iOS app or web settings, then configure your MCP client either via stdio (npx burn-mcp-server with BURN_MCP_TOKEN) or via the remote HTTPS endpoint https://burn-mcp-server.vercel.app/api/mcp using a Bearer token header. No installation is required for the remote mode.

`search_vault`

Search your Burn Vault for bookmarks by keyword (searches title, tags, AI takeaway)

`list_vault`

List bookmarks in your Vault, optionally filtered by category

`list_sparks`

List your Sparks (bookmarks you have read, with 30-day lifespan). Includes spark insight and expiry date.

`search_sparks`

Search your Sparks by keyword (searches title, tags, AI takeaway, spark insight)

`get_bookmark`

Get full details of a single bookmark including AI analysis and extracted content

`get_article_content`

Get full article content and AI analysis for a bookmark by ID (same as get_bookmark)

`fetch_content`

Fetch article/tweet content from a URL. Works with X.com (bypasses GFW via proxy), Reddit, YouTube, Bilibili, WeChat, and any web page. First checks Supabase cache, then fetches live.

`list_categories`

List all Vault categories with article counts

`list_flame`

List bookmarks in your Flame inbox (24h countdown). Shows AI triage info (strategy, relevance, novelty, hook) and time remaining. Use this to see what needs attention before it burns to Ash.

`get_flame_detail`

Get full details of a Flame bookmark including extracted article content, AI analysis, and reading guidance. Use this to deep-read a bookmark before deciding its fate.

`get_collections`

List all your Collections with article counts and AI overview themes

`get_collection_overview`

Get a Collection by name with its AI overview and linked bookmarks metadata

`move_flame_to_spark`

Move a Flame bookmark to Spark (mark as worth reading). Sets 30-day Spark lifespan.

`move_flame_to_ash`

Burn a Flame bookmark to Ash (not worth keeping).

`move_spark_to_vault`

Promote a Spark bookmark to permanent Vault storage.

`move_spark_to_ash`

Burn a Spark bookmark to Ash (not valuable enough to vault).

`batch_triage_flame`

Triage multiple Flame bookmarks at once. Each decision moves a bookmark to Spark or Ash.

`write_bookmark_analysis`

Write AI analysis results into a bookmark. Agent analyzes content with its own LLM, then writes structured results back to Burn. Only provided fields are merged — existing data is preserved.

`create_collection`

Create a new Collection to group related bookmarks together.

`add_to_collection`

Add bookmarks to an existing Collection. Duplicates are silently ignored.

`remove_from_collection`

Remove bookmarks from a Collection.

`update_collection_overview`

Write an AI-generated overview for a Collection (theme, synthesis, patterns, gaps).

`add_watched_source`

Watch an X user, RSS feed, or YouTube channel — new posts auto-appear in Burn Flame on each scrape.

`list_watched_sources`

List all active watched sources (X users, RSS feeds, YouTube channels).

`remove_watched_source`

Stop watching a source. Use list_watched_sources to find the source ID.

`scrape_watched_sources`

Fetch new content from all watched sources (or one specific source) and add new items to Burn Flame. Call this on a schedule or on demand.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "burn mcp server": {
            "burn": {
                "command": "npx",
                "args": [
                    "burn-mcp-server"
                ],
                "env": {
                    "BURN_MCP_TOKEN": "<your-token>"
                }
            }
        }
    }
}

McpServers

{
    "burn": {
        "command": "npx",
        "args": [
            "burn-mcp-server"
        ],
        "env": {
            "BURN_MCP_TOKEN": "<your-token>"
        }
    }
}

Burn — Personal Knowledge Base MCP Server

Want this badge in your own README? Grab the markdown atburn451.cloud/developers#badges.

Your reading data as an AI-accessible knowledge base. 26 tools for Claude, Cursor, Windsurf, and any MCP-compatible agent.

Watch the real Claude → Burn walkthrough— the exact read-only prompt, tool calls, sources, and limits are published so you can reproduce it.

You need a free Burn account to use this server.Fastest path: open Burn on the web→Settings → MCP Server → Copy Access Token. Prefer the app?Download Burn for iPhone. Burn has a free tier (5 saves/day, all 26 MCP tools included) and a Pro plan at $4.99/month for unlimited saves.

Burn is a read-later app with a 24-hour deadline— saves auto-burn unless you read or rescue them. The honest answer to the bookmark graveyard problem— research suggests 84% of saved bookmarks are never revisited(Bergman, Whittaker & Schooler, 2021).

- Flame→ New links. 24h to read or they burn.
- Spark→ You read it. Stays 30 days.
- Vault→ Permanent. Your curated knowledge.
- Ash→ Expired. They had their chance.

The MCP server lets your AI agent search, triage, organize, and analyze everything you've saved. Built for Claude users who want their reading history as context.

Migrating from another tool?Burn is a Pocket replacement(Mozilla shut Pocket down July 2025), an Omnivore alternative(acquired by ElevenLabs late 2024), and a Matter app alternative.
- Create a free Burn account —iOS appor web
- Open the app →Settings → MCP Server → Generate token → Copy

The server exchanges your token for a short-lived Supabase session and caches it in~/.burn/mcp-session.json. No re-login on each run.

Use the hosted endpoint with the same Burn token. Nothing runs locally:

{ "mcpServers": { "burn": { "type": "http", "url": "https://burn-mcp-server.vercel.app/api/mcp", "headers": { "Authorization": "Bearer <your-token>" } } } }

For claude.ai, openSettings → Connectors → Add custom MCP, use the endpoint above, and add the sameAuthorizationheader.

Run the npm package locally in Claude Desktop, Cursor, Windsurf, or Claude Code:

{ "mcpServers": { "burn": { "command": "npx", "args": ["burn-mcp-server"], "env": { "BURN_MCP_TOKEN": "<your-token>" } } } }

- "What did I save about system design?"
- "Triage my Flame — what should I keep?"
- "Create a collection from my AI bookmarks"

{ "mcpServers": { "burn": { "command": "npx", "args": ["burn-mcp-server"], "env": { "BURN_MCP_TOKEN": "<your-token>" } } } }

claude mcp add burn -e BURN_MCP_TOKEN=<your-token> -- npx burn-mcp-server

- "Go through my Flame inbox, read each article, keep anything about AI agents and burn the rest."
- "What's about to expire in the next 6 hours that I'd regret losing?"

- "Search my Vault for everything on context engineering and summarize the main schools of thought."
- "Which authors do I save most often? What does that say about my reading gaps?"

- "Create a collection called 'MCP in production' from my saves, then write an overview of what my sources agree and disagree on."
- "Add a watched source for Simon Willison's blog so new posts land in my Flame."

- "I'm writing about read-later apps. Pull every relevant bookmark I have and list the claims I can support with a source."

Honest boundaries, so you know what to expect before connecting an agent:

- No save/add-URL tool.The agent can search, read, triage, and organize what's already in your Flame/Spark/Vault — it can't add a new URL to your inbox itself. Save from the iOS app, the Chrome Web Clipper, or burn451.cloud first; the agent picks up from there.
- Keyword search, not semantic/vector search.search_vaultandsearch_sparksmatch on title, tags, and the AI-generated takeaway — not embedding similarity. Search by topic keyword, not by vague description.
- No delete.Tools move bookmarks between Flame → Spark → Vault → Ash; nothing permanently deletes a row through MCP.
- Remote and local transports, but no OAuth flow yet.The hosted endpoint uses Streamable HTTP athttps://burn-mcp-server.vercel.app/api/mcp; local clients runnpx burn-mcp-serverover stdio. Both require a token you generate and paste once per client.
- Read/triage is the mature path; agent-writes-back is newer.write_bookmark_analysisandupdate_collection_overviewlet the agent write structured notes back to your data. These write tools are newer and less battle-tested than the read/search/triage tools above.

Personal knowledge management— Your agent searches your reading history to answer questions, find patterns, and surface forgotten gems. SeeAI bookmark management concepts.

Research workflows— Create collections on topics you're exploring. Agent writes overviews synthesizing your sources. Examples:vault as Karpathy LLM wiki,Paul Graham vault,Simon Willison vault.

Reading triage— Agent reviews your Flame inbox, reads the content, decides what's worth keeping. Solves the reading list appproblem of saves piling up.

Cross-tool intelligence— Use with Claude Code, Cursor, or Windsurf. Your bookmarks become context for coding, writing, and thinking. The MCP server architectureis open and documented.

Free vs paid choice— Burn's free tier includes all 26 MCP tools (5 saves/day); Pro is $4.99/month. See free bookmark manager comparisonfor honest landscape across 8 truly-free options.

*One ofBURN_MCP_TOKENorBURN_SUPABASE_TOKENrequired.

The container builds the TypeScript source, keeps only production dependencies, and runs the stdio server as a non-root user. Authentication remains a runtime requirement; no token is included in the image.

docker build -t burn-mcp-server:2.1.1 . docker run --rm -i -e BURN_MCP_TOKEN burn-mcp-server:2.1.1

For a Glama release, use the repository Dockerfile (or the equivalent build stepsnpm ciandnpm run build), set the CMD tonode dist/index.js, and declareBURN_MCP_TOKENas a required secret string. The Glama build test needs a dedicated test-account token supplied through its placeholder/secret configuration; never commit that token or use a maintainer's primary account token. After the build test succeeds, publish a Glama release and sync the server profile.

- Token scoped to your data only (Row Level Security)
- Status flow enforced: Flame → Spark → Vault, or → Ash
- Rate limit: 30 calls/min per session
- Tokens expire after 30 days

- App:burn451.cloud
- iOS App:App Store
- npm:burn-mcp-server
- Chrome Extension:Burn Web Clipperon Chrome Web Store
- Read-later app comparison (10 tools tested):best-read-later-app-2026
- AI bookmark organizer rankings:best-ai-bookmark-manager-2026
- Pocket alternative pillar:pocket-alternative-2026
- vs Raindrop comparison:burn-vs-raindrop
- Developer docs:burn451.cloud/developers

Remote MCP server for Docsie video-to-docs automation and workspace knowledge search.

An AI-powered documentation management system with hierarchical context management and session continuity.

Score, tailor, and edit your resume from Claude Code and any MCP client.

Tailor resumes to job postings, generate cover letters, and export PDFs through AI agents

List and create Manthan concept-card decks from an AI agent — no AI quota spent for imports.

AI-native office suite MCP server. Create, read, update docs, spreadsheets, and slides with 23 tools.

Turn any AI agent into an academic researcher that can search, read, cite, and write full literature reviews autonomously.

MCP server that drafts winning client proposals in your own voice — no API key, runs locally in Claude Desktop.

Connect Scrivener 3 writing projects to Claude, ChatGPT, and other AI assistants. 60+ tools for manuscript management, writing analysis, semantic search, character/plot memory, and content enhancement.

AI document editing for agents and humans: draft, section-precise edit, and export styled .docx/PDF; agents self-sign-up for a free account in one call.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Description

About

Details

Jump to

Setting up with Highlight

From the repository

search_vault

list_vault

list_sparks

search_sparks

get_bookmark

get_article_content

fetch_content

list_categories

list_flame

get_flame_detail

get_collections

get_collection_overview

move_flame_to_spark

move_flame_to_ash

move_spark_to_vault

move_spark_to_ash

batch_triage_flame

write_bookmark_analysis

create_collection

add_to_collection

remove_from_collection

update_collection_overview

add_watched_source

list_watched_sources

remove_watched_source

scrape_watched_sources

Claude Desktop / Cursor

McpServers

Burn — Personal Knowledge Base MCP Server

Install

More like this

Sequential Thinking

Time

Filesystem

EverArt

Google Drive

Context 7

`search_vault`

`list_vault`

`list_sparks`

`search_sparks`

`get_bookmark`

`get_article_content`

`fetch_content`

`list_categories`

`list_flame`

`get_flame_detail`

`get_collections`

`get_collection_overview`

`move_flame_to_spark`

`move_flame_to_ash`

`move_spark_to_vault`

`move_spark_to_ash`

`batch_triage_flame`

`write_bookmark_analysis`

`create_collection`

`add_to_collection`

`remove_from_collection`

`update_collection_overview`

`add_watched_source`

`list_watched_sources`

`remove_watched_source`

`scrape_watched_sources`