---
title: "What is Amnesia?"
description: "An overview of Amnesia Reader, its Obsidian-native reading model, integrations, and public API surface."
canonical: https://amnesia-docs.pages.dev/overview/what-is-amnesia/
source: "src/content/docs/overview/what-is-amnesia.md"
---

# What is Amnesia?

Amnesia is an ebook and PDF reader built as an **Obsidian plugin**. It keeps books inside the same
workspace as notes instead of treating reading as a separate application: EPUB and PDF files open in
an Amnesia reader view, selections can become annotations or notes, and integrations can address the
reader through a typed public API.

The current plugin manifest identifies Amnesia as version **0.5.3**, requires Obsidian **1.0.0 or
later**, and is not marked desktop-only. The public API reports its own independent version,
**1.0.0**.

## What Amnesia adds to Obsidian

### EPUB and PDF reading

Amnesia registers its reader for `.epub` files and routes `.pdf` files into the same reader surface.
The reader is designed around document navigation rather than a single exported-note workflow, so a
book can remain an addressable object while you read and work elsewhere in the vault.

PDF rendering uses the plugin's MuPDF pipeline and bundled worker/WASM assets. EPUB and PDF therefore
share the Amnesia reader shell while keeping format-specific rendering and location models underneath.

### Annotations that remain connected to the source

The plugin has first-class models for highlights, bookmarks, notes, and links. Reader locations and
selectors are retained with those records so other parts of the plugin — and external integrations —
can refer back to the document rather than only to copied text.

Amnesia also includes Doc Doctor integration for workflows that need to move between reading,
annotation, and documentation/knowledge-management operations.

### Local-first reading with optional services

A local books folder is part of the plugin settings and defaults to `Books`. Server support is
optional and is **disabled by default**. OPDS, Calibre, synchronization, caching, offline management,
and the bundled server extend the system when needed, but they are not prerequisites for opening an
EPUB or PDF already present in an Obsidian vault.

EPUB and PDF workflows are functional today and continue to stabilize across mixed-library environments.
Collections and server-related systems are already present and wired in the codebase, but they are still
under active integration and hardening and should be treated as beta/1.0.0-gating work today rather than
as absent features.

## Public API

Amnesia constructs a public API when the plugin loads. Another Obsidian plugin can use the plugin
instance directly; Templater, QuickAdd, DataviewJS, and similar scripts can use the convenience
global:

```js
// Another Obsidian plugin
const api = this.app.plugins.plugins['amnesia']?.api;

// Script automation
const api = window.Amnesia;
```

The current API root is organized around these interfaces:

```text
AmnesiaAPI
├── version
├── state
│   ├── reader
│   ├── library
│   ├── highlights
│   └── bookmarks
├── commands
│   ├── reader
│   ├── library
│   ├── highlights
│   ├── bookmarks
│   ├── notes
│   ├── links
│   └── mupdf
├── events
├── hooks
├── ui
└── connect(pluginId, capabilities)
```

`state.*` values are read-only Svelte stores. `events` provides typed `on`, `off`, and `once`
subscriptions, while `hooks` exposes cancellable pre-operation hooks. `connect()` creates a scoped API
handle from the capability set requested by an integration.

:::note[Interface shape is not a stability promise]
The source tree contains both stable and still-evolving interfaces. A member appearing in the public
types does **not** by itself mean every operation is production-stable. Use the labels in the
[API overview](/api/overview/) and individual reference pages as the availability contract.
:::

## Capability model

The capability vocabulary currently includes:

- `read-state`
- `read-document`
- `write-annotations`
- `write-bookmarks`
- `write-library`
- `admin`

The top-level API created by Amnesia is admin-scoped for the plugin itself. External integrations can
use `connect()` to request a narrower handle:

```js
const amnesia = window.Amnesia;
const api = await amnesia.connect('my-plugin', [
  'read-state',
  'write-annotations',
]);
```

Capabilities are useful for declaring intent and constraining cooperative integrations; they are not
an Obsidian security sandbox. See [Capabilities and permissions](/api/reference/capabilities/) for the
full contract.

## Plugin lifecycle and discovery

After the public API has been created, Amnesia publishes it as `window.Amnesia` and emits the
`amnesia:ready` workspace event with the API object and plugin version. Integrations that cannot rely
on plugin load order can use that event as their discovery point.

## Where to go next

- [Getting started](/getting-started/installation/) — install a repository build and open an EPUB or PDF.
- [Amnesia API overview](/api/overview/) — stability labels and supported integration surfaces.
- [Connect to the API](/api/guides/connect-to-the-api/) — establish an API handle from another plugin or script.
- [Add notes and links](/api/guides/add-notes-and-links/) — work with source-linked annotations.
- [Use the MuPDF API](/api/guides/render-with-mupdf/) — PDF extraction and annotation primitives.

<sub>Product overview verified against the current Amnesia plugin implementation on 2026-08-17.</sub>