Glean

Glean is a self-hosted RSS reader and personal knowledge management platform designed for developers, researchers, and information-heavy users who want full data ownership over their reading workflow. It aggregates content from RSS and Atom feeds, enables saving articles and external URLs as bookmarks, and offers folder and tag-based organization for building a personal knowledge base.

The platform ships as a Docker Compose stack with three distinct services — a React web application, a FastAPI backend, and a background worker — giving users clear separation between the UI, API layer, and asynchronous processing. Feed updates happen automatically every 15 minutes via a Redis-backed task queue, and an optional Milvus integration enables AI-powered preference learning and smart content recommendations.

Glean’s standout feature is its built-in MCP (Model Context Protocol) server, which exposes the user’s RSS knowledge base as a set of tools callable by AI assistants like Claude Desktop. Users can search their subscriptions, retrieve articles, and query reading history conversationally without leaving their AI workflow. The platform also ships as an Electron desktop application for macOS, Windows, and Linux alongside the web deployment.

The project follows a structured phased roadmap: core RSS features and organization tools are complete, an embedding-based preference pipeline is actively in development, and future phases cover a rule engine, AI summaries with bring-your-own-key support, a Chrome extension, and a mobile PWA.

What You Get

• RSS Subscription - Subscribe to RSS 2.0, RSS 1.0, and Atom feeds with OPML import and export for migrating subscriptions between readers
• Smart Reading - Clean, distraction-free article reader with content filtering and chronological timeline view for browsing unread items
• Read Later Queue - Save articles to a read-later list with automatic cleanup of old items so the queue stays manageable
• Bookmarks with Organization - Save articles from feeds or any external URL and organize them with multi-level folders and tags
• Background Feed Sync - Automatic feed updates every 15 minutes via an arq worker and Redis task queue, running independently of the web interface
• MCP Server for AI Assistants - Built-in Model Context Protocol server exposing search, article retrieval, and subscription listing as callable tools for Claude Desktop and other MCP clients
• Admin Dashboard - Separate web interface on port 3001 for user management, system configuration, and monitoring
• AI-Powered Recommendations (WIP) - Milvus-backed embedding pipeline that learns reading preferences and scores content as Recommended, Normal, or Not Interested
• Electron Desktop App - Native desktop application for macOS, Windows, and Linux built from the same React codebase as the web version
• API Token Management - Create named long-lived API tokens with optional expiration for authenticating MCP clients and external integrations

Common Use Cases

• Research aggregation - A graduate student subscribes to academic journals and preprint servers, saves relevant papers as bookmarks, and tags them by topic for systematic literature review
• Newsletter replacement - A developer unsubscribes from email newsletters and consolidates all RSS sources into Glean, letting preference learning surface the most relevant content first
• AI-assisted reading - A knowledge worker connects Claude Desktop to Glean’s MCP server and asks questions like ‘show me articles about Rust async from this week’ without leaving their AI workflow
• Content curation workflow - A blogger subscribes to industry feeds, saves candidate articles as bookmarks, and organizes them into folders by topic before writing weekly roundups
• Team knowledge base - A small team runs a shared Glean instance where members subscribe to different sources and bookmark articles into shared folders for collaborative research

Under The Hood

Architecture

Glean uses a layered monorepo structure with Python and TypeScript workspaces maintained independently but deployed together via Docker Compose. The backend splits into two long-running processes: a FastAPI HTTP server handling synchronous requests and an arq worker managing asynchronous feed fetching, cleanup, and embedding generation. These communicate through Redis, keeping the request path fast while background processing scales independently. A service layer sits between router handlers and the database session, with SQLAlchemy async sessions injected via FastAPI dependency injection — ensuring no business logic leaks into routing code. The app factory pattern in the API entry point makes the OSS layer explicitly composable: extra routers, middleware, and lifecycle hooks can be injected without modifying core files, an architectural decision that cleanly anticipates a SaaS extension layer. The MCP server is mounted as a Streamable HTTP sub-application within FastAPI, sharing the process lifecycle while maintaining its own session manager and token verifier.

Tech Stack

The backend runs on Python 3.11 with FastAPI for the HTTP layer, SQLAlchemy 2.0 with asyncpg for asynchronous PostgreSQL access, and Alembic for schema migrations. Arq provides Redis-backed task queuing with cron scheduling for periodic feed fetches and cleanup jobs. The optional Milvus vector database handles embedding storage and semantic similarity for the preference learning pipeline, with MinIO for object storage and etcd for coordination. FastMCP implements the Model Context Protocol server, enabling AI assistant tool integrations. The frontend is a React 18 application built with TypeScript and Vite, using TanStack Query for server state, Zustand for client state, and Tailwind CSS for styling — organized in a Turborepo monorepo with shared packages for API client, types, i18n, logging, and UI components. Electron Builder packages the web app as a cross-platform desktop application.

Code Quality

The project maintains an extensive test suite across more than 30 test files covering unit tests, integration tests, and API endpoint tests — including authentication flows, feed operations, MCP tool behavior, and embedding validation. The backend enforces strict type checking via Pyright in strict mode alongside Ruff for linting and formatting; the frontend applies TypeScript strict mode, ESLint, and Prettier. Pre-commit hooks enforce all of these on every commit. Error handling is explicit throughout: custom exception classes propagate through service layers to typed FastAPI exception handlers, and async/await is applied consistently with no blocking operations in the request path. Public methods carry docstrings with parameter and return documentation, and inline comments explain non-obvious logic in the background task and preference learning code.

What Makes It Unique

Glean’s most novel capability is its first-class MCP server integration, which exposes a personal RSS knowledge base as tool-callable context for AI assistants — letting users search their reading history, retrieve articles, and list subscriptions conversationally through Claude Desktop or any MCP-compatible client. This positions the app not just as an RSS reader but as a personal information layer that feeds into AI workflows. The app factory pattern creates a documented extension point for composing additional functionality on top of the OSS core without forking it. The optional Milvus-powered embedding pipeline for reading preference learning is a genuine attempt to bring ML-driven content ranking to self-hosted RSS infrastructure, a combination typically found only in commercial products. The dual deployment model — lite without Milvus and full with the complete AI stack — thoughtfully accommodates users across a wide range of infrastructure capabilities.

Self-Hosting

Glean is released under the GNU Affero General Public License v3.0 (AGPL-3.0). This license allows you to freely use, modify, and self-host the software for any purpose, including commercial internal use. The key condition is network copyleft: if you modify Glean and make it available over a network to other users, you must publish your modifications under the same license. For developers, researchers, or teams running a private instance, this has no practical restriction. For anyone intending to build a hosted service on top of Glean’s code and offer it to third parties, the AGPL requires disclosing those modifications — a meaningful constraint compared to more permissive licenses.

Running Glean yourself means taking ownership of the full operational stack. A typical deployment uses Docker Compose to manage the backend API, background worker, PostgreSQL database, Redis task queue, and optionally Milvus with etcd and MinIO for the AI recommendation pipeline. The lite deployment omitting Milvus is viable on modest hardware — a small VPS or home server with a few hundred megabytes of RAM and a standard PostgreSQL instance is sufficient. The full deployment with Milvus is considerably heavier and requires planning for the vector database’s coordination services and storage. You are responsible for performing database backups from the PostgreSQL data volume, pulling updated Docker images when new releases ship, running Alembic database migrations before starting updated containers, and monitoring service health. No automated management tooling is provided beyond Docker Compose health checks.

There is no official hosted or commercial cloud tier for Glean at the time of writing — all users operate on the same open-source codebase with no feature differentiation. This means self-hosters get every capability, including AI features, without a paywall. In exchange, there are no support SLAs, no managed upgrade paths, no automated backups, and no high-availability configuration provided out of the box. Community support is available through GitHub Issues and a Discord server. Teams requiring production-grade reliability guarantees, automated failover, or enterprise support arrangements would need to build those operational practices themselves or engage specialist hosting providers.