# Standard Notes MCP > Standard Notes connects your AI client directly to an encrypted vault, allowing it to read, write, and organize private data using tags. It manages notes in a secure environment without exposing plaintext content to the AI agent. ## Overview - **Category:** fort-knox - **Price:** Free - **Tags:** end-to-end-encryption, secure-storage, data-privacy, knowledge-base, tag-management, sync ## Description **Standard Notes MCP Server - Encrypted Note & Tag Management** Listen up, 'cause this thing lets your AI client talk directly to your Standard Notes vault—and it's fully encrypted. You don't gotta worry about copy-pasting sensitive drafts or exporting logs just to give your agent something to chew on. This server gives your agent the tools to read, write, and organize all your private data using tags, keeping everything locked down inside the Standard Notes system. **Getting Your Data Into Play** You start by pulling what you need. You can run `list_notes` to grab a quick list of every note title in your vault; it'll show you the unique IDs too. If you wanna see the full details for just one item—a note, tag, or extension—you use `get_item_details` with its UUID. To track down all the organizational categories, run `list_tags`, which lists every defined tag and its ID in your account structure. **Building and Modifying Content** When you need to write something new, you kick it off with `create_note`, passing in a title and the full body text for an entirely fresh, encrypted note. If that existing draft needs tweaking, don't recreate it; just use `update_note`. You give it the target note's UUID and the fresh text, and boom, the content gets replaced. **Organizing Your Notes with Tags** You gotta keep track of this stuff. To start a new category, you run `create_tag` to build a brand-new tag in your account’s taxonomy. Once that's done, if you wanna link a tag to an existing note, you use `tag_note`, supplying both the required UUIDs for the item and the tag. **Maintenance and Cleanup** When you make changes—any changes—you gotta pull everything together with `sync_items`. This runs a full sync, making sure your local context matches whatever's on the official Standard Notes server. If an item is garbage or outdated, you use `delete_item` to wipe it out forever by its unique UUID; remember, that action is permanent and irreversible. **The Full Scope of Control** For setup purposes, if your agent needs credentials for a specific account email address, it calls `get_auth_parameters`. These tools let you manage the entire lifecycle of your secure knowledge base. You can create notes (`create_note`), change them (`update_note`), and link tags (`tag_note`). You'll also always know what's available by listing titles (`list_notes`) or pulling full item details (`get_item_details`). Don’t forget you can manage the organizational structure itself—you create tags (`create_tag`), list them all (`list_tags`), and then delete whatever trash is hanging around using `delete_item`. Finally, running `sync_items` keeps everything current with Standard Notes. ## Tools ### create_note Creates an entirely new, encrypted note using a provided title and body text. ### create_tag Creates a brand-new organizational tag within your account's taxonomy. ### delete_item Permanently removes any item (note, tag, or extension) using its unique UUID; this action cannot be undone. ### get_auth_parameters Retrieves the necessary authentication parameters for a given account email address. ### get_item_details Pulls and displays all content details for one specific item (note, tag, or extension) by its UUID. ### list_notes Retrieves a list of every encrypted note title in the vault; the content remains protected until decrypted. ### list_tags Lists all currently defined tags and their UUIDs within your Standard Notes account structure. ### sync_items Performs a full synchronization operation, pulling the latest changes from the official Standard Notes server. ### tag_note Associates an existing tag with a specific note using both their required UUIDs. ### update_note Replaces the content of an existing note when provided with the target note's UUID and new text. ## Prompt Examples **Prompt:** ``` List all active tags in my vault. Next, read out the title and UUID strings of my notes so I can assign categorizations properly. ``` **Response:** ``` Securely querying local Standard Notes indexes... **Tag Taxonomies (`list_tags`)**: - `Personal Infrastructure` (UUID: a1b2...) - `Work Configurations` (UUID: c3d4...) - `Project Research` (UUID: x8z1...) **Vault Notes Retrieved (`list_notes`)**: - Title: "Architecture Decisions 2026" [UUID: 99x1...] - Title: "NGINX Routing Documentation" [UUID: 88z2...] Please clarify which specific item you would like me to dissect using `get_item_details`. ``` **Prompt:** ``` Write a completely new structured document titled 'Q3 Marketing Directives'. Save it to my records mentioning our emphasis on standardizing B2B outreach. ``` **Response:** ``` Generating structured output through the `create_note` implementation... - **Metadata Title**: *Q3 Marketing Directives* - **Generated Body Content**: *This quarter demands a robust standardization of our B2B pipeline strategies. Client outreach synchronization will be prioritized...* **STATUS: VAULT RECORD SAVED ✅** The isolated item UUID generated from the central server was successfully registered locally. ``` **Prompt:** ``` System cleanup required. Permanently delete the draft attached to UUID 'note-xyz1' leveraging the standard removal procedures. ``` **Response:** ``` Verifying constraints for permanent destruction. Transmitting standard secure vectors across endpoints matching target ID to `delete_item` protocols... Targeted File: `note-xyz1`. **PERMANENT ERASURE CONFIRMED 🗑️** The item correlating to your input parameter UUID has been entirely removed from the persistent repository securely. ``` ## Capabilities ### Retrieve encrypted notes List all note titles and unique IDs in the vault via `list_notes`, or pull the full details of a single item using `get_item_details`. ### Create and modify drafts Use `create_note` to save entirely new content, or use `update_note` when you need to change existing notes by their UUID. ### Manage tags and organization Build a taxonomy by creating new categories (`create_tag`), listing all current ones (`list_tags`), or linking a tag to an item using `tag_note`. ### Keep the data synced Run `sync_items` after making changes to ensure your local context matches the official Standard Notes server state. ### Permanently delete assets Use `delete_item` to remove notes, tags, or extensions forever by their unique UUID. This action is irreversible. ## Use Cases ### Archiving a Project Vault A system admin needs to document an incident log. First, they use `list_notes` to confirm the UUID of the 'Incident Report' note. Then, the agent uses `get_item_details` to read the existing content and `update_note` to append today's resolution steps, finally using `tag_note` to mark it as 'Closed'. ### Mapping Research Concepts A researcher has notes scattered across different topics. They run `list_tags` and see gaps. The agent then uses `create_tag` for a new category, like 'Methodology', and tells the AI to find all relevant notes using their UUIDs so they can be grouped later. ### Clearing Out Old Drafts The user finished an old research draft but doesn't need it anymore. They identify the specific item by its UUID and instruct the agent to use `delete_item` to remove it permanently, keeping the vault clean. ### Preparing a Handover Package The PM needs to pass project knowledge off. The agent uses `list_notes` to pull all notes tagged 'Handover' (using `tag_note`) and then compiles them into a single summary document using the content from `get_item_details`. ## Benefits - Stop manually copying data. Use `list_notes` and `get_item_details` so your agent can pull research content directly from the encrypted source into your workflow. - Maintain perfect organization flow by using `tag_note`. Instead of remembering where you filed something, just tell your agent to tag it with 'Project X' and let the tool handle the connection. - Never worry about data drift. The `sync_items` tool ensures that any changes made locally are matched against the official server state before you proceed. - Build a robust knowledge graph by using `create_tag` and grouping related notes. This gives your AI client structure it can rely on, moving beyond simple text files. - Need to fix an old document? You don't have to recreate it. Use `update_note` with the existing UUID to surgically change only the required content, keeping all history intact. ## How It Works The bottom line is, you tell your AI client what knowledge action to take—reading, writing, or organizing—and it executes that command securely within your encrypted Standard Notes vault. 1. Attach the Standard Notes MCP integration and configure your endpoint URL and JWT Access Token. 2. Instruct your AI client to perform a read action, such as listing tags (`list_tags`) or notes (`list_notes`), which provides necessary UUIDs. 3. Tell your agent exactly what to do: 'Update note 99x1' with the text 'Action Items' and tag it using `tag_note`.' ## Frequently Asked Questions **How does Standard Notes MCP Server handle data encryption when I use list_notes?** The notes remain encrypted until the AI client decrypts them using your user keys. The server only lists titles and UUIDs, ensuring content stays protected throughout the process. **Can I update a note's content without knowing its UUID?** No, you must provide the target note’s UUID to use `update_note`. You can find this ID first by running `list_notes` and identifying the specific record. **If I delete an item using delete_item, is it truly gone?** Yes. The tool permanently deletes the item (note, tag, or extension) from the repository. This action cannot be reversed or recovered. **Does sync_items fix all my data problems?** The `sync_items` function performs a full synchronization check between your local context and the official server state, ensuring integrity across all assets. **Before I can run any other tool, how do I get the necessary authorization credentials using `get_auth_parameters`?** You must first call `get_auth_parameters`. This routine retrieves the specific authentication parameters for your account email. You then use these details to generate a valid JWT Access Token needed by all subsequent calls. **What is the correct sequence for managing tags using `list_tags` and then associating them with a note via `tag_note`?** First, run `list_tags` to pull every existing tag UUID defined in your vault. Once you have both the target tag's UUID and the specific note's UUID, you use `tag_note` to establish the link. **When I need the full content and metadata for one item, why should I use `get_item_details` instead of relying on `list_notes`?** `list_notes` only provides a high-level index or list view. By contrast, `get_item_details` pulls the entire payload—including full content and all associated metadata—for the exact UUID you provide. **If I want to change existing note content, what are the constraints when using `update_note` on a specific UUID?** `update_note` requires both the target note's UUID and the new plaintext body. Be aware that this function overwrites the entire current text; it does not merge or append data by default. **If I am self-hosting Standard Notes on my own server, can this integration still connect to it?** Absolutely. The `SN_SERVER_URL` parameter allows complete flexibility. You can use the official `https://api.standardnotes.com` endpoint, or simply provide the custom domain pointing to your private server infrastructure. **Are my encrypted notes fully exposed to the AI model during a query?** The server passes local encrypted blocks down to the MCP layer. While `list_notes` primarily retrieves metadata and structural UUIDs, executing an extraction using `get_item_details` or writing entirely new content via `create_note` will securely transmit standard text directly to the model's localized context. **What is the purpose of the 'sync_items' functionality?** Standard Notes employs a client-side database synchronization architecture. The `sync_items` module retrieves exclusively the differences or modifications made since the execution of your last tracked `sync_token`. It ensures local operational states match the remote vault natively.