Get AI summaries of any video or article — Sign up free
Obsidian - Create Random Notes with ChatGPT Templates thumbnail

Obsidian - Create Random Notes with ChatGPT Templates

Josh Plunkett·
5 min read

Based on Josh Plunkett's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Install the Text Generator plugin via Obsidian Community Plugins, and turn off Restricted Mode so plugin installation works.

Briefing

Random tables are a staple of tabletop RPGs, but maintaining them is tedious—especially when new books and options keep arriving. This workflow uses Obsidian’s Text Generator plugin to generate fully formed RPG content on demand by sending carefully written templates to ChatGPT, turning “I need a shop/inventory/encounter/rule-of-thumb” into a quick Ctrl U or Space Space trigger.

The core setup starts with installing the Text Generator plugin from Obsidian’s Community Plugins, then disabling Restricted Mode so plugins can be installed. After installation, users must add an OpenAI API key from platform.openai.com. The guide emphasizes cost control: OpenAI billing settings include usage limits, and failing to set a hard monthly cap can lead to surprise charges. Once the key is pasted into Obsidian, the plugin is configured to use a model—GPT 3.5 turbo is recommended for lower cost, while GPT4 is described as more expensive and access-restricted.

Configuration then focuses on output quality and template behavior. Max tokens is increased (the presenter lands around 650 to avoid errors seen at higher values), and temperature is raised to 0.8 from 0.7 to make results more varied. The plugin’s prompt/template folders are pointed at a local directory (text generator slash prompts), and options like including front matter and headings are enabled so generated content fits neatly into Obsidian notes. A key quality-of-life feature is enabling token/cost estimation for templates, which surfaces an “estimate tokens for a template” option in Obsidian’s command palette.

Once the plugin is working, the real payoff comes from templates. Templates live in the Text Generator templates package structure and include front matter fields such as prompt ID, name, description, author, tags, and version. The template “name” is what appears when triggering templates via Ctrl U, so emojis can be used to make selection easier. The guide’s examples show how simple prompt instructions can produce structured RPG assets: an inn template generates an innkeeper profile, signature drinks in a Markdown table (name, cost, description), meals with prices, patrons, and a rumor hook. An encounter template generates a Dungeons and Dragons 5th edition encounter for a specified party size and level, then outputs an encounter block plus descriptive text.

To keep encounters compatible with downstream tools, the template instructions include strict formatting rules—such as requiring monster names to match exactly what’s in the monster manual and avoiding pluralization that can break initiative tracking. The workflow also supports context injection: highlighting text in a note and triggering the template lets the generated content match the current scene (e.g., “land of lollipops and candy canes” becomes a themed encounter).

Beyond inns and encounters, the same method is used to generate job boards, adventures, dungeons, shops, apothecaries, armories, and even Mythic GM emulator-style prompts like a Magic 8 Ball. The guide also notes system-agnostic potential: as long as ChatGPT has enough information about a ruleset, templates can be adapted for other RPGs. For localization concerns, the guide suggests keeping offline backups, and it highlights a practical expansion path by generating items sourced from Cobalt Press through the OGL.

Finally, templates are shared via Patreon, and the cost is framed as manageable—testing reportedly totals around 12 cents—while the plugin’s token estimation helps users stay aware of spend. The overall message is that templated AI generation can replace years of manual random-table upkeep, letting GMs spend more time on play and less time building content lists.

Cornell Notes

Obsidian’s Text Generator plugin can create tabletop RPG content instantly by sending user-written templates to ChatGPT. After installing the plugin and adding an OpenAI API key, users configure model choice (GPT 3.5 turbo for cost), output limits (max tokens around 650), and randomness (temperature around 0.8). Templates stored in text generator slash prompts can generate structured notes like inn menus, rumors, and Dungeons and Dragons 5th edition encounters, including encounter blocks formatted for compatibility with other tools. Strict prompt instructions—such as requiring monster names to match the monster manual exactly—help prevent formatting issues. Token/cost estimation options make it easier to control spending while using AI on demand.

How does the workflow turn “random tables” into on-demand content inside Obsidian?

It replaces manually maintained tables with templates that call ChatGPT. Users install the Text Generator plugin, configure an OpenAI API key, then trigger either highlighted text (Ctrl J) or templates (Ctrl U, or Space Space for menu-triggered options). The plugin sends the template plus any highlighted context to ChatGPT and inserts the returned result into the note, producing things like shop inventories, inn descriptions, rumors, and encounter blocks without hand-building tables.

What configuration choices matter most for getting usable RPG output?

The guide focuses on three knobs: model selection, max tokens, and temperature. GPT 3.5 turbo is recommended as cheaper than GPT4. Max tokens is increased to about 650 to avoid truncation/errors seen at lower defaults. Temperature is raised to 0.8 from 0.7 to increase variety. It also enables template options like including front matter and headings so generated content fits Obsidian’s note structure.

Why do templates need strict formatting rules for encounters?

Because downstream RPG tooling can be sensitive to exact text. The encounter template instructs ChatGPT to use monster names exactly as listed in the monster manual and to avoid pluralization (e.g., “three Goblin,” not “three goblins”), since initiative tracking can break on plural forms. It also tells the model to place the encounter block at the bottom so descriptive text doesn’t get mixed into the stat block.

How does context-awareness work when generating content?

Templates can incorporate highlighted text from the current note. For example, highlighting a phrase like “land on lollipops” and triggering the encounter template makes the generated encounter match the scene’s theme. This lets GMs steer outputs by writing a short cue in the note, then letting the template expand it into a full result.

How does the guide manage the cost of using ChatGPT repeatedly?

It recommends setting OpenAI usage limits (a hard monthly cap) in billing settings to prevent surprise charges. Inside Obsidian, it enables token/cost estimation for templates so users can check “estimate tokens for a template” or “estimate tokens for a current document” from the command palette. The guide reports low costs during testing (around 12 cents) and notes that costs can rise faster if multiple AI plugins are used.

Can the same template approach work beyond D&D 5e?

Yes, the guide frames templates as system-agnostic in principle: users can ask for content for Pathfinder, Shadowrun, or other RPGs as long as ChatGPT has enough reference material. It suggests Pathfinder 2 may work particularly well because mechanics are broadly available online, and it demonstrates generating items that include Cobalt Press content via the OGL.

Review Questions

  1. What specific template instructions help ensure generated encounter stat blocks remain compatible with initiative tracking?
  2. Which three configuration settings (model, max tokens, temperature) are adjusted to balance cost, completeness, and randomness?
  3. How does highlighting text in Obsidian change what a template generates, and why is that useful during play?

Key Points

  1. 1

    Install the Text Generator plugin via Obsidian Community Plugins, and turn off Restricted Mode so plugin installation works.

  2. 2

    Create an OpenAI account and add an API key in the plugin options; set OpenAI usage limits to avoid unexpected monthly charges.

  3. 3

    Use GPT 3.5 turbo for lower cost, and tune max tokens (around 650) and temperature (around 0.8) for better variety without errors.

  4. 4

    Store templates under text generator slash prompts and use template front matter (including the template “name”) so Ctrl U shows the right selectable items.

  5. 5

    Write templates with strict formatting constraints—especially for monster names and encounter block placement—to prevent broken stat blocks.

  6. 6

    Inject scene context by highlighting text before triggering a template, letting generated content match the current location or theme.

  7. 7

    Enable token/cost estimation so users can check expected spend before generating large or frequent outputs.

Highlights

A single template trigger can generate a complete inn package—innkeeper, signature drinks as a Markdown table, meals with prices, patrons, and a rumor—without manual table upkeep.
Encounter templates can be made tool-friendly by forcing exact monster names (no pluralization) and requiring the encounter block to appear at the bottom.
Token/cost estimation inside Obsidian helps keep AI usage predictable, while OpenAI billing usage limits prevent surprise bills.
Templates become context-aware by using highlighted text, allowing themed encounters like “land of lollipops and candy canes” to generate accordingly.

Topics

  • Obsidian
  • Text Generator Plugin
  • ChatGPT Templates
  • Tabletop RPG Content
  • Random Encounters

Mentioned