Obsidian - Create Random Notes with ChatGPT Templates
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.
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?
What configuration choices matter most for getting usable RPG output?
Why do templates need strict formatting rules for encounters?
How does context-awareness work when generating content?
How does the guide manage the cost of using ChatGPT repeatedly?
Can the same template approach work beyond D&D 5e?
Review Questions
- What specific template instructions help ensure generated encounter stat blocks remain compatible with initiative tracking?
- Which three configuration settings (model, max tokens, temperature) are adjusted to balance cost, completeness, and randomness?
- How does highlighting text in Obsidian change what a template generates, and why is that useful during play?
Key Points
- 1
Install the Text Generator plugin via Obsidian Community Plugins, and turn off Restricted Mode so plugin installation works.
- 2
Create an OpenAI account and add an API key in the plugin options; set OpenAI usage limits to avoid unexpected monthly charges.
- 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
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
Write templates with strict formatting constraints—especially for monster names and encounter block placement—to prevent broken stat blocks.
- 6
Inject scene context by highlighting text before triggering a template, letting generated content match the current location or theme.
- 7
Enable token/cost estimation so users can check expected spend before generating large or frequent outputs.