Raindrop.io MCP Server for LLM Bookmark Access

Overview

This project implements an MCP (Model Context Protocol) server that exposes your Raindrop.io bookmarks as tools consumable by LLMs and other MCP-aware clients. By running the server you can give large language models programmatic access to bookmark collections, bookmark metadata, and simple search capabilities — enabling retrieval-augmented generation, citeable sources, and automated reading-list workflows without sharing your Raindrop credentials directly to the model.

The server acts as a bridge between the Raindrop.io API and any system that understands the MCP spec. It implements one or more MCP tools (for example: listBookmarks, getBookmark, searchBookmarks, listCollections) and returns structured results so LLMs can call them deterministically during inference or reasoning. This is useful for building agents, chat assistants, or custom LLM pipelines that should reference your personal or team bookmark corpus.

Features

• MCP-compatible endpoints exposing Raindrop.io bookmarks as callable tools
• Read-only access to Raindrop collections, bookmarks, and basic search
• Simple configuration via environment variables or a .env file
• Works with local development (npm, Node.js) and containerized deployments
• Structured JSON responses ideal for LLM tool invocation and grounding
• Minimal setup to integrate bookmarks into retrieval-augmented generation

Installation / Configuration

Requirements: Node.js (LTS), npm or yarn, and a Raindrop.io Personal Access Token.

1. Clone the repository and install dependencies:

git clone https://github.com/hiromitsusasaki/raindrop-io-mcp-server.git
cd raindrop-io-mcp-server
npm install

2. Create a .env file (or set environment variables directly). Minimal example:

# .env
RAINDROP_TOKEN=raindrop_personal_access_token_here
PORT=4000
MCP_API_KEY=optional_server_api_key_for_auth

3. Start the server in development:

npm start
# or, if provided
node src/index.js

4. (Optional) Run with Docker:

# build
docker build -t raindrop-mcp-server .
# run
docker run -e RAINDROP_TOKEN=$RAINDROP_TOKEN -p 4000:4000 raindrop-mcp-server

Environment variables reference:

Available Tools

The server exposes a set of MCP tools (examples below). Each tool is intended to be invoked by an LLM via the Model Context Protocol and returns JSON results.

• listCollections — return user’s Raindrop collections (id, title, count)
• listBookmarks — list bookmarks in a collection with pagination
• getBookmark — fetch a single bookmark by id
• searchBookmarks — search bookmarks across collections using keywords
• getMetadata — retrieve bookmark metadata (tags, excerpt, created_at)

Example tool signatures (conceptual):

{
  "name": "raindrop.listBookmarks",
  "description": "List bookmarks in a given collection",
  "parameters": {
    "type": "object",
    "properties": {
      "collection_id": { "type": "string" },
      "page": { "type": "integer" },
      "per_page": { "type": "integer" }
    },
    "required": ["collection_id"]
  }
}

Example API Calls

Curl example to fetch collections (replace host/port as needed):

curl -H "Authorization: Bearer $MCP_API_KEY" \
     "http://localhost:4000/mcp/tools/raindrop/listCollections"

Example: list bookmarks in collection via MCP tool invocation:

curl -X POST "http://localhost:4000/mcp/invoke/raindrop.listBookmarks" \
  -H "Content-Type: application/json" \
  -d '{"collection_id":"12345","page":1,"per_page":20}'

Example JSON response (trimmed):

{
  "bookmarks": [
    {
      "id": "67890",
      "title": "Article Title",
      "excerpt": "Short summary...",
      "link": "https://example.com/article",
      "tags": ["ai", "research"],
      "created_at": "2024-02-01T12:34:56Z"
    }
  ],
  "page": 1,
  "per_page": 20,
  "total": 42
}

Use Cases

• Retrieval-augmented generation: allow an LLM to cite specific bookmarks (URL + excerpt) when answering user queries about saved content.
  • Example flow: a user asks “Show me my resources on prompt engineering.” The LLM invokes searchBookmarks with query “prompt engineering”, then summarizes the top results.
• Agent workflows: let an LLM perform multi-step tasks that involve bookmarks, e.g., compile a reading list, open links for deeper scraping, or extract highlights.
  • Example: call listCollections, then listBookmarks for the “Reading List” collection, then generate a 500-word summary of top 5 bookmarks.
• Team knowledge base: expose shared team bookmarks to internal assistants so answers are grounded in the team-curated links rather than web search.
• Automation and sync: periodically fetch bookmarks for offline indexing or feed them into a vector database for semantic search.

Available Resources

• Source code and issues: https://github.com/hiromitsusasaki/raindrop-io-mcp-server
• Raindrop.io API documentation: use your Raindrop token and consult Raindrop’s API for rate limits and scopes.
• Model Context Protocol (MCP): consult the MCP specification or your chosen LLM platform docs to connect MCP tools as external tool endpoints.

Notes and Best Practices

• The server is intended for read-only access — do not expose your RAINDROP_TOKEN in client-side code or public repositories.
• Use MCP_API_KEY or other network controls to limit who can invoke the MCP endpoints.
• Rate limits: respect Raindrop.io API rate limiting; cache results where appropriate for heavy usage.
• For production, run the server behind TLS and an authenticated gateway (e.g., reverse proxy, API gateway).