Overview

Docent is a grad-school AI assistant with three main tools: a Reading Queue that syncs your Mendeley library, a Studio research engine for AI-powered literature reviews, paper analysis, and notebook building, and an Ecosystem page that connects all the external tools Docent integrates with.

Every feature is callable three ways: from the terminal (docent …), from Claude via MCP (docent serve), or from this web UI (docent ui).

How it fits together

Mendeley  →  "Docent-Queue"  →  docent reading sync-from-mendeley
                                     ↓
                             Reading queue (local)
                                     ↓
                         docent serve  →  Claude MCP  →  Studio actions
                                     ↓
                          docent ui  →  this UI

Quick-start

Studio

The Studio is Docent's research engine. Choose an action, fill in a topic or artifact, select a backend, and run. Results stream live — you can see each phase as it progresses. Use the UI at localhost:7432 or call commands directly from the terminal.

Research actions

Utility actions

Backends

Output destinations

Guide files

Attach PDFs or text files to steer the research. Pass one or more with --guide-files path/to/file.pdf. In the Studio UI, use the Browse button to pick files from your machine, or drag and drop onto the form.

Config keys

Ecosystem

The Ecosystem page (accessible from the sidebar) lists every external tool Docent integrates with — search engines, AI backends, reference managers, and notebook services. Each card shows what the tool does, when to use it, and how to install it.

Tool categories

Checking your ecosystem

Run docent doctor to see the status of every installed integration. The Settings page also runs this automatically and shows a health dashboard.

Plugin Guide

Docent is built on a plugin architecture. Every tool you see — Reading Queue, Studio — is a plugin registered at startup. You can write your own plugins to add new actions callable from the CLI, Claude via MCP, and this UI.

Plugin structure

# my_plugin/__init__.py
from docent.core.tool import Tool, action, ProgressEvent
from pydantic import BaseModel

class MyPlugin(Tool):
    name = "my_plugin"
    description = "My custom tool"

    class ConfigModel(BaseModel):
        some_setting: str = "default"

    @action(description="Do something useful")
    def my_action(self, ctx, topic: str):
        yield ProgressEvent(phase="start", message=f"Processing {topic}")
        # ... your logic here
        yield ProgressEvent(phase="done", message="Finished")

Registering a plugin

Add your plugin to pyproject.toml under [project.entry-points."docent.plugins"]:

[project.entry-points."docent.plugins"]
my_plugin = "my_plugin:MyPlugin"

After installing your package, run docent list to confirm the plugin appears. All actions are automatically exposed as MCP tools following the toolname__actionname convention.

ProgressEvent fields

Config keys

Each plugin declares its config schema via a ConfigModel. Users set values with docent <toolname> config-set --key <k> --value <v>. Config is stored in ~/.docent/config.toml under a [toolname] section.

Reading Queue

Manage your reading list. Each entry is a document from Mendeley — a paper, book, or book chapter. All state lives in ~/.docent/data/reading/queue.json. Metadata is always authoritative from Mendeley — Docent caches it locally for fast reads.

Adding & syncing documents

Moving through the queue

Editing & organising

Search & stats

Export & maintenance

CLI Reference

All commands follow the pattern docent <tool> <action> [options].

Top-level commands

Config commands (per-tool)

Config keys — Reading tool

MCP Setup

Docent exposes all registered tool actions as MCP tools, so you can call them directly from Claude (or any MCP-compatible client) without leaving your conversation.

1. Start the server

Run docent serve. It starts a stdio MCP server — keep it running while you use Claude, or wire it into your MCP config so Claude starts it automatically.

2. Configure Claude

Add a .mcp.json at your project root (or in ~/.claude/ for global access):

{
  "mcpServers": {
    "docent": {
      "command": "docent",
      "args": ["serve"]
    }
  }
}

Claude will then have access to all Docent tools. Action names follow the pattern reading__next, reading__done, etc. (tool name + double underscore + action name).

Tool naming convention

reading__add
reading__next
reading__start
reading__done
reading__show
reading__search
reading__stats
reading__edit
reading__set_deadline
reading__move_up
reading__move_down
reading__move_to
reading__export
reading__remove
reading__queue_clear
reading__sync_from_mendeley
reading__sync_status
reading__config_show
reading__config_set

Settings

All settings are stored in ~/.docent/config.toml. You can edit this file directly or use docent reading config-set from the terminal, or the Settings page in this UI.

Config file location

~/.docent/config.toml

Example config

[reading]
database_dir = "/Users/you/Documents/Papers"
queue_collection = "Docent-Queue"

Environment variable overrides

All config values can be overridden with environment variables prefixed DOCENT_. See .env.example in the repo for the full list.