AI-Assisted Campaign Prep: Manage Massive Campaign Histories & Ensure Continuity

—

As a Game Master, managing a long-running campaign can feel like a daunting task, especially when it comes to keeping track of intricate histories and ensuring continuity. That’s where AI-assisted campaign prep comes in. By leveraging AI tools, you can streamline your campaign management processes, from summarizing sessions to maintaining NPC consistency, all while enhancing your storytelling. Imagine converting your legacy session notes into a searchable index that not only saves you time but also enriches your game. Let’s dive into a practical workflow that will transform your campaign prep experience.

1. Master campaign index: purpose and components

Creating a master campaign index is essential for any Game Master (GM) looking to maintain continuity in a long-running tabletop RPG campaign. This index serves as a single-file overview that links all your sessions, non-player characters (NPCs), timeline entries, tags, and asset paths. By centralizing this information, you create a grounding source for AI queries and contradiction detection, ensuring that your campaign remains coherent and engaging for your players.

To set up your master campaign index, you’ll want to start with a schema that includes key fields such as ID, Session, Date, Title, Key Events, NPCs, Tags, Continuity Links, and more. For example, your index could look something like this:

By using this structured format, you’ll be able to easily reference specific sessions and link them to NPCs or events, fostering a rich narrative continuity.

1.1 Key fields for the index

When building your campaign index, it’s crucial to define the key fields that will hold your data. Essential fields include ID (a unique identifier), Session number (to track the order), Date (when the session occurred), Title (a brief name for the session), Key Events (important happenings in JSON format), NPCs (characters involved), Tags (for categorization), and Continuity Links (to connect to previous sessions).

1.2 Example record and schema

To help you visualize how your index should look, here’s an explicit example of a single record formatted in JSON. This structure will not only organize your information but also make it easily queryable by AI tools for continuity checks:

{
    "ID": "S001",
    "Session": 1,
    "Date": "2024-03-01",
    "Title": "Tavern Brawl",
    "KeyEvents": ["Fight breaks out", "Elric challenges Jorak"],
    "NPCs": ["Elric", "Jorak"],
    "Tags": ["#combat", "#tavern"],
    "SourcePath": "/02-Sessions/TavernBrawl_v1.0.md",
    "Checksum": "abc123hash"
}

2. Ingesting legacy content: strategies and pipelines

Ingesting legacy content is a vital step for any GM looking to build a comprehensive campaign index. This process involves gathering old session notes, audio recordings, or any relevant materials, and converting them into a format that your index can utilize. A well-defined strategy will help you convert these materials into actionable data that can enhance your campaign’s continuity.

Step-by-Step Workflow:

1. Gather Legacy Content: Collect all existing notes, recordings, and documents. Organize them into a designated folder (e.g., 01-Legacy).
2. Convert Formats: Use tools like Whisper for audio transcription or OCR (Optical Character Recognition) for scanned documents to convert them into text.
3. Chunk Data: Break the text into manageable parts (2,000-4,000 tokens) with a 200-word overlap to ensure context is preserved.
4. AI Prompting: Use AI prompts to summarize and extract key events, NPCs, and tags from each chunk.
5. Merge into Master Index: Integrate the processed data into your campaign index, ensuring all links and references are correctly established.

2.1 Text sources to consider

When ingesting legacy content, it’s crucial to consider a variety of text sources to ensure you’re capturing all relevant information. Common sources include session notes, chat logs from platforms like Discord or Slack, VTT (Virtual Tabletop) combat logs, and audio recordings.

2.2 Chunking and preprocessing rules

Chunking is the process of breaking down your content into smaller, manageable pieces to facilitate AI processing. It’s essential to apply specific rules to ensure that these chunks are coherent and contextually rich.

Here are some guidelines:

• Chunk Sizes: Aim for 2,000-4,000 tokens for transcripts, while emails or notes can range from 1,000-2,000 tokens.
• Overlap: Maintain a 200-word overlap between chunks to preserve context.
• Preprocessing: Normalize dates to a standard format (YYYY-MM-DD), and map character name aliases to their canonical IDs. Strip any non-essential metadata that might confuse the AI.

3. AI-assisted summarization: concise, linked outputs

AI-assisted summarization is a powerful tool for GMs looking to convert large amounts of session data into structured, actionable summaries. By leveraging AI, you can produce concise outputs that are easy to link back to your campaign index and help maintain continuity across sessions.

Here’s how to get started:

1. Input Your Chunks: Feed the AI your chunked data along with a prompt requesting a structured summary.
2. Specify Output Format: Indicate the desired output format, such as YAML or JSON, to ensure compatibility with your index.
3. Review AI Output: Check the AI-generated summaries for accuracy and completeness before integrating them into your index.
4. Link Back to Index: Make sure that key events and NPCs mentioned in the summary are linked to their respective entries in your campaign index.
5. Repeat for All Chunks: Continue this process for each chunk until all legacy content is summarized.

3.1 Prompt templates for session summarization

Creating effective prompts for AI-assisted summarization can significantly enhance the quality of your outputs. Here are some templates you can use to ensure you get the information you need in a structured format.

Here are three examples:

1. General Summarization:

       Summarize the following session notes into YAML format with fields: Summary, Key Events, NPCs, and Tags.
       

2. D&D 5e Specific:

       For D&D 5e, summarize the session notes and include likely skill checks, CR hints, and character stats along with the summary.
       

3. Narrative-Heavy Games:

       Summarize the session focusing on character relationships and player choices, output in YAML format.
       

3.2 Three output styles: bullet, paragraph, event log

When it comes to summarizing your sessions, having different output styles can cater to various needs within your campaign preparation. Here are three effective formats you can use:

1. Bullet Summary: Ideal for quick reference, this format lists key events in bullet points. Aim for 6-12 items to keep it concise.

   Example:

   • Fight breaks out in the tavern.
   • Elric challenges Jorak to a duel.
2. Paragraph Recap: This style provides a narrative overview of the session, typically between 150-250 words. It’s perfect for player handouts.

   Example:

   “In the bustling tavern, tensions rose as Elric confronted Jorak, leading to an unexpected brawl that drew the attention of all patrons…”

3. Event Log: For detailed tracking, this format lists events chronologically, suitable for timeline ingestion. Each entry should follow the format:
   YYYY-MM-DD | Event | NPCs.

   Example:

   2024-03-01 | Fight breaks out | Elric, Jorak.

Mapping which downstream file each style feeds into (like player handouts or the index) can help streamline your preparation process and ensure consistency.

4. Tagging, taxonomy, and metadata schemes

Tagging is a crucial part of maintaining continuity in your campaign. A well-structured tagging system allows you to categorize and quickly retrieve information related to different aspects of your sessions. This can significantly enhance your ability to track NPCs, events, and themes over time.

Start with a YAML frontmatter template:

At the top of your session notes, include a YAML frontmatter that limits tags to around eight categories such as combat, location, NPC, and timeline. This ensures that your tags remain manageable and relevant.

  ---
  tags:
    - combat
    - tavern
    - exploration
  ---
  

4.1 Example tag hierarchy and naming conventions

To create an effective tagging system, consider establishing a hierarchy in your tags that reflects the relationships between different elements of your campaign. This could involve categorizing tags into groups like NPCs, locations, and plots, and using a structured naming convention.

4.2 How to tag for continuity checks

To maintain continuity in your campaign, it’s important to implement a tagging system specifically designed for tracking contradictions and potential retcons. This can help you quickly identify any inconsistencies across sessions.

Here’s how to do it:

1. Link Prior Sessions: Use tags to reference previous sessions (e.g., links: [S041, NPC-Elric]) and flag any timeline-critical events.
2. Continuity Tags: Introduce specific tags like conflict-check, retcon-risk, and timeline-gap. These can be automatically generated when AI detects a contradiction.
3. Tag Lifecycle: Establish a lifecycle for your tags, categorizing them as created, reviewed, or archived based on their relevance.

✨ Discover the Ultimate Tavern Bundle ✨

Stop prepping for hours. Get 350,000+ digital assets to create immersive campaigns instantly.

🎲 Get the Ultimate Toolbox Now

Instant Download • Lifetime Access

5. NPC continuity and characterization system

Maintaining consistency in your NPCs is essential for a rich, immersive gaming experience. By implementing a structured system for tracking NPC traits, relationships, and changes over time, you can ensure that your characters remain believable and engaging.

To build this system:

1. Create an NPC YAML Model: Your model should include fields for ID, name, aliases, first appearance, last updated, traits, relationships, and secrets.
2. Implement a Workflow: Develop a six-step workflow for NPC continuity that includes extracting data, appending new information, running AI checks, updating timelines, flagging contradictions, and generating reminders.

  id: NPC001
  name: Elric
  aliases: [Elric the Bold]
  first_appearance: 2023-01-15
  last_update: 2024-03-01
  traits: [brave, hot-headed]
  relationships: [Jorak: rival, Sira: ally]
  secrets: [lost brother]
  

Incorporating player feedback into your NPC records can provide valuable insights into how players perceive characters, allowing for more nuanced and engaging storytelling.

5.1 NPC record template

To facilitate easy tracking and updates, use a structured template for your NPC records. This template should encompass all necessary fields to capture the essence and evolution of each character.

  ---
  id: NPC001
  name: Elric
  aliases: [Elric the Bold]
  traits: 
    - brave
    - hot-headed
  relationships: 
    - Jorak: rival
    - Sira: ally
  secrets: 
    - lost brother
  change_log: 
    - date: 2024-03-01
      change: Updated traits based on player interactions
  player_reactions: 
    - "Players found him relatable and complex."
  ---
  

5.2 Automated checks for personality/knowledge drift

To maintain NPC consistency, it’s critical to implement automated checks that can identify personality or knowledge drift over time. These checks can help you ensure that your characters remain true to their established traits and backstories.

Here’s how to set up these checks:

1. Define Drift Types: Identify the types of checks you want to run, such as trait-contradiction, knowledge-contradiction, and relationship-contradiction.
2. Scoring Rubric: Develop a scoring system (0-5) to evaluate the severity of drift. This will help you prioritize which characters need immediate attention.
3. Remediation Actions: Based on the drift severity, outline suggested actions, such as providing a retroactive explanation, implementing a minor retcon, or reminding players of past details.

6. Timeline extraction and visual timelines

Extracting a timeline from your campaign sessions is a valuable way to visualize the flow of events and maintain continuity. By synthesizing key events into a chronological format, you can easily identify gaps, overlaps, and contradictions in your narrative.

Here’s a step-by-step process:

1. Synthesize Events: Gather key events from your session notes and structure them into a CSV file with columns for Date, Event, ID, Related NPCs, and Tags.
2. Flag Gaps: Identify any gaps in the timeline, particularly those exceeding 30 days, which may indicate a need for further exploration or clarification.
3. AI Synthesis: Use AI tools to summarize and create arc summaries based on the events extracted.
4. Visualize: Choose a visualization tool (like Timeline JS or Obsidian) to create an interactive timeline that can be easily referenced during gameplay.
5. Regular Updates: Continuously update your timeline as new sessions occur to keep it current and useful.

6.1 Steps to Extract Timeline Entries from Sessions

To effectively manage your campaign continuity, extracting timeline entries from your session notes is crucial. A well-organized timeline can help you track events, NPC actions, and significant plot developments. Here’s a simple procedure to get started:

1. Gather Session Logs: Collect all relevant session notes that contain event information. Ensure each session has an in-game date or a corresponding real-world date for reference.
2. Identify Key Events: Go through each session and highlight significant events, NPC interactions, and plot developments. Make sure to tag NPCs involved in each event for easy reference later.
3. Create a CSV Template: Set up a CSV (Comma-Separated Values) file with columns for Date, Event, NPC IDs, Tags, and Source Session ID. This format will allow you to sort and filter entries easily.
4. Use an AI Prompt for Extraction: Utilize an AI tool to synthesize the events into the CSV format. A sample prompt might be: “Extract key events from the session notes and output a CSV with columns: Date, Event, NPC IDs, Tags, Source Session ID.”
5. Review and Validate: After generating the CSV, review the entries to ensure accuracy and completeness. Make any necessary adjustments before finalizing the timeline.

6.2 Tools and Formats for Timeline Visualization

Once you have your timeline entries extracted, visualizing them can significantly enhance your campaign management. Several tools can help you create engaging and informative timelines, making it easier for you and your players to track the story’s progression.

1. Timeline JS: This tool allows you to create interactive timelines using Google Sheets or CSV files. Simply format your data according to their requirements, and you can embed the timeline on a website or share it with players. The format includes fields like Date, Headline, Text, and Media.
2. Obsidian with Timeline Plugin: If you’re already using Obsidian for your campaign notes, consider adding the Timeline plugin. This allows you to visualize your events directly within your notes, making it easy to reference and update as your campaign progresses.
3. Lucidchart: For a more diagrammatic approach, Lucidchart can be used to create flowcharts and timelines. It offers collaborative features, allowing multiple GMs to work on a timeline together, ensuring continuity across different story arcs.
4. Aeons: This tool is specifically designed for TTRPGs and supports CSV imports. It’s great for campaigns with complex branching narratives, allowing you to visualize multiple timelines and how they interconnect.
5. Tiki-Toki: This online tool is excellent for creating visually stunning timelines with images and videos. It’s user-friendly, making it easy to add events and customize the appearance to fit your campaign’s theme.

7. Version Control, Backups, and Archiving

Maintaining version control and backups is essential for any campaign, especially if you’re using AI-assisted prep. This process helps you avoid data loss and ensures that you can easily revert to previous versions if needed. Here’s how to establish a solid versioning and backup system:

1. Implement a Version Control System: Use a platform like Git for version control. Set up a repository for your campaign notes and regularly commit changes. A good practice is to push updates after each session, creating a clear history of changes.
2. Create a Backup Schedule: Plan a regular backup cadence. A recommended schedule could be daily incremental backups to a cloud service, weekly full backups, and monthly cold archives to an external hard drive. This ensures that you have multiple recovery points.
3. Use Git LFS for Large Files: If you have large assets (like maps or images), use Git LFS (Large File Storage) to keep your repository lightweight. This allows you to track changes to large files without bloating your version control history.
4. Archive Completed Arcs: Once a story arc is complete, archive the associated files into a timestamped zip folder. This keeps your working directory clean while preserving all previous content for future reference.
5. Test Restores Regularly: To ensure that your backups are effective, perform regular restore tests. This can be done quarterly to verify that your backup files are intact and can be successfully restored.

7.1 Simple Versioning Schemes for Session Notes

Having a clear versioning scheme for your session notes is vital for maintaining order and clarity in your campaign management. Here’s a straightforward approach to versioning your notes:

1. Adopt Semantic Versioning: Use a semantic versioning format (MAJOR.MINOR) for your session notes. For example, if you make significant changes to the structure of your notes, increase the MAJOR version. If you only make minor edits, increase the MINOR version.
2. Include a Version Suffix in Filenames: When saving your session notes, append the version number to the filename. For instance, a session file might be named “2024-03-01_Session_TavernBrawl_v1.2.md.”
3. Add Version Information in YAML Frontmatter: Within your session files, include a YAML frontmatter section at the top. This should contain fields for the version number, date, and any relevant tags or links.
4. Document Changes: Maintain a changelog within your session notes. This can be a simple list of changes made with each version, helping you track the evolution of your notes.
5. Use Git Tags for Important Releases: When you reach significant milestones in your campaign, use Git tags to mark these points. For example, you might tag a release as “arc-complete” to signify the completion of a narrative arc.

7.2 Backup Cadence and Storage Recommendations

Implementing a comprehensive backup strategy is crucial for protecting your campaign data from loss. Here’s how to set up a solid backup cadence and choose the right storage solutions:

1. Establish a Layered Backup Strategy: Start with a local SSD for daily work, then back up to an encrypted cloud service (like Google Drive with Cryptomator) for redundancy. Finally, archive to a cold storage solution (like an external HDD or S3 Glacier) for long-term preservation.
2. Daily Incremental Backups: Perform daily backups that capture any changes made during the day. This ensures you can recover recent work without losing significant progress.
3. Weekly Full Backups: Conduct a full backup of all your campaign files once a week. This should include all sessions, NPC files, and asset packs, providing a comprehensive snapshot of your campaign.
4. Monthly Cold Archives: Every month, archive your completed arcs and older sessions to a cold storage solution. This keeps your active working directory clean while preserving historical data.
5. Quarterly Restore Tests: Schedule quarterly tests to restore files from your backups. This ensures that your backup system is functioning properly and that you can recover your data in case of an emergency.

8. Virtual Tabletop (VTT) Sync and Asset Management

Managing your Virtual Tabletop (VTT) assets effectively is crucial for maintaining continuity in your campaign. Here’s how to ensure that your VTT assets are synced with your campaign notes:

1. Export VTT Data: Regularly export your VTT JSON data (from platforms like Foundry or Roll20) and parse it into a Markdown format. This allows you to integrate combat logs and other VTT information directly into your session notes.
2. Create an Asset Registry: Maintain a CSV file (VTT-assets.csv) that tracks all your VTT assets. This should include columns for AssetID, AssetName, FilePath, ImportedDate, UsedInSessions, and LicenseURL. This registry will help you manage your assets and ensure continuity.
3. Map Asset IDs to the Campaign Index: In your master campaign index, create a field for AssetID. This allows you to link specific VTT assets to their corresponding notes and events, facilitating easy reference during sessions.
4. Tag Source Information: When importing VTT data into your session notes, make sure to tag the source as “vtt.” This helps differentiate between various sources of information and maintain clarity.
5. Regularly Update the Asset Registry: As you acquire new assets or make changes to existing ones, update your asset registry. This ensures that you have an accurate record of what you own and how it’s being used.

8.1 How to Map VTT Assets to Campaign Index

Mapping your VTT assets to your campaign index is a key step in maintaining continuity and organization. Here’s a clear process to accomplish this:

1. Export VTT Assets: Begin by exporting your VTT assets in JSON format. This can typically be done through your VTT platform’s export feature.
2. Parse the Data: Use a script or tool to parse the VTT JSON data into a more manageable format, such as a CSV. This CSV should include fields for AssetID, AssetName, FilePath, ImportedDate, UsedInSessions, and LicenseURL.
3. Append to Campaign Index: Add a new field in your campaign index for AssetID. This allows you to link specific VTT assets directly to your session records.
4. Create a Lookup Command: Set up a command or script that allows you to quickly look up asset usage within your campaign. This can help you track which assets have been used in specific sessions and where they’re referenced.
5. Regular Updates: As you add new VTT assets, make sure to append them to your asset registry and update your campaign index. This ensures that your records are always current and accurate.

8.2 Ensuring Map and Encounter Continuity

To maintain continuity in your campaign, it’s essential to ensure that maps and encounters are correctly tracked and updated. Here’s a method to achieve this:

1. Tag Maps and Encounters: When you create or modify a map or encounter, tag it in your session notes. Include relevant information such as the map version, encounter ID, and any associated NPCs or events.
2. Link to the Campaign Index: In your master campaign index, create links to the corresponding session notes for each map and encounter. This allows for quick reference during gameplay.
3. Version Control for Maps: Implement a versioning system for your maps. Whenever a map is updated, save it as a new version and update the links in your session notes and campaign index.
4. Run Pre-Session Checks: Before each session, run an AI continuity check for any active maps and encounters. This helps identify any discrepancies or changes that need to be addressed.
5. Maintain Metadata: Keep a record of encounter metadata, such as spawn lists and triggers, within your campaign index. This ensures that all relevant information is easily accessible during gameplay.

9. On-the-Fly Continuity Aids for Live Sessions

During live sessions, having quick access to continuity aids can help keep the game flowing smoothly. Here’s how to prepare for on-the-fly continuity checks:

1. Prepare Quick AI Queries: Create a set of micro-prompts that you can use during sessions to get quick recaps or information. For example, a prompt like “What does the party currently know about [NPC/PlotTag]?” can provide instant context.
2. Develop Micro-Summary Templates: Create templates for quick summaries that you can display during sessions. Aim for 30–60 word recaps that capture essential details without overwhelming you or your players.
3. Establish a Quick-Check Checklist: Prepare a checklist of current known facts, NPC statuses, and unresolved hooks. This can serve as a quick reference guide during gameplay.
4. Utilize Mobile Tools: Consider using lightweight local AI tools or apps on your mobile device to access these resources instantly during sessions.
5. Log Quick Notes: Keep a notepad or digital document handy to jot down quick notes or reminders during sessions. This helps capture important details that may need to be addressed later.

9.1 Quick Prompts and Micro-Summaries to Display

When running a live session, quick prompts and micro-summaries can help you provide essential context without interrupting the flow of the game. Here are two effective micro-prompts you can use:

1. 30s GM Recap Prompt: “30s GM recap: What does the party currently know about [NPC/PlotTag]?” This prompt will help you quickly summarize key details about an NPC or plot element, ensuring everyone is on the same page.
2. Session Checklist Prompt: “Session checklist: unresolved hooks, NPC statuses, active timers (IDs).” This will allow you to keep track of ongoing storylines and NPC states, helping you maintain continuity.

9.2 Example Live Session Workflow

To streamline your live session workflow and ensure you’re prepared for continuity checks, follow this three-step process:

1. Pre-Session Preparation: Begin by pulling relevant session index rows and running a pre-check on NPC statuses and unresolved hooks. Aim to do this about 10 minutes before your session starts.
2. Live Session Management: During the session, use your quick prompts for recaps and quick lookups of NPC sheets. Keep your micro-prompt for quick summaries handy, aiming for less than 60 seconds for lookups.
3. Post-Session Wrap-Up: After the session, take about 15 minutes to save any quick notes or updates to your session files. Route these notes into your ingestion pipeline for processing.

10. Privacy, Data Security, and Player Secrets

When using AI-assisted prep, it’s essential to prioritize privacy and data security, especially concerning player secrets. Here’s how to safeguard your campaign data:

1. Flag Player-Secrets: Clearly mark any files that contain player secrets with a flag (e.g., player-secrets: true). This ensures that you know to handle these files with extra caution.
2. Process Secrets Locally: Use local tools for processing sensitive information. This minimizes the risk of exposure when using cloud AI tools.
3. Use Encryption: Store player secrets in an encrypted vault, such as Cryptomator, to protect their privacy. This adds an extra layer of security to your sensitive data.
4. Obtain Player Consent: At the beginning of your campaign (Session 0), obtain explicit consent from players regarding how their information will be used and processed. Keep a log of this consent for transparency.
5. Audit AI Usage: Maintain a record of when and how AI tools are used in your campaign. This can include logging input hashes to track what data is processed, helping you stay accountable.

By establishing clear privacy protocols, you can foster trust among your players while still leveraging the benefits of AI-assisted prep.

10.1 How to Redact and Anonymize Data Before Using Cloud AI

To protect player privacy when using cloud AI, it’s vital to redact and anonymize data effectively. Here’s a straightforward process to follow:

1. Flag Files for Redaction: Before processing, flag any files containing player secrets with a clear indicator (e.g., redaction: true). This will help you remember to apply redaction procedures.
2. Replace Identifying Information: Substitute player names with placeholders like PC1, PC2, etc. This ensures that no personal identifiers are exposed during processing.
3. Remove Sensitive Details: Strip out any personal contact information, locations, or dates that may reveal player identities.
4. Create a Redaction Script: Develop a script that automates the redaction process for you. This can streamline the workflow and minimize human error.
5. Conduct a Verification Step: After redaction, use an AI prompt to verify that the output contains no personal identifiable information (PII). For example, ask the AI to list redacted token placeholders to ensure compliance.

10.2 Local Alternatives and Hybrid Approaches

Using local AI tools for sensitive queries can help you strike a balance between leveraging AI technology and protecting player privacy. Here’s how to implement a hybrid approach:

1. Utilize Local Models: Tools like Ollama for summarization and Whisper for speech-to-text (STT) can be run locally. This keeps sensitive data off the cloud and under your control.
2. Implement a Hybrid Workflow: Process initial data locally using Whisper for STT, then anonymize the outputs before sending summaries to cloud AI for further processing. This keeps sensitive information secure while still benefiting from cloud capabilities.
3. Store Anonymized Data: After processing, merge the anonymized summaries back into your local files while maintaining a separate vault for player secrets. This ensures that sensitive data is not mixed with your regular campaign notes.
4. Regularly Review Your Process: As you integrate local and cloud tools, regularly assess the effectiveness of your hybrid approach. Ensure that your workflow remains efficient without compromising data security.
5. Seek Player Feedback: Encourage players to provide feedback on your privacy practices, ensuring that they feel comfortable with how their information is being handled.

11.2 Filewatcher/Shortcuts recipe: auto-archive finished arcs

To streamline your campaign management, automating the archiving of finished story arcs is crucial. Using tools like Filewatcher (a macOS automation tool) or Shortcuts can save you time and ensure that your completed sessions are organized and easily accessible. Here’s a simple recipe to automatically archive your finished arcs:

1. Setup Filewatcher: Install Filewatcher and configure it to monitor your session folder (e.g., /02-Sessions/).
2. Detect Tagging: Create a rule to watch for the arc-complete tag added to any session file.
3. Run Shell Script: When the tag is detected, execute a shell script that compresses the entire arc folder into a zip file and moves it to a backup directory (e.g., /06-Backups/).
4. Generate AI Summary: Call an AI service to create a summary of the arc, which can be saved as arc_summary.md.
5. Email Recap: Finally, email the recap to your GM group for their records.

12. Practical examples and full before/after transformations

When working with AI-assisted campaign prep, transforming raw session data into structured records is essential for maintaining continuity and ease of access. Here’s how you can convert a raw session transcript into a structured YAML output:

1. Gather Raw Data: Start with your raw session transcript, which may include dialogue, notes, and action descriptions.
2. Use AI for Structuring: Prompt the AI to convert this transcript into a structured YAML format that includes fields like Session, Date, Summary, Entities, Events, and Tags.
3. Insert Metadata: Make sure to include any relevant metadata, such as the date of the session and the names of involved NPCs (non-player characters).
4. Store in Index: Save this structured output in your campaign index, linking it back to the original raw transcript for easy reference.
5. Review for Accuracy: Finally, check the AI output for any inaccuracies or omissions that may need correction.

  Session: 001
  Date: 2024-03-01
  Summary: The party meets Elric in the tavern.
  Entities:
    - NPC: Elric
  Events:
    - Description: Elric reveals the location of the hidden treasure.
  Tags: [meeting, treasure]
  

12.1 Example: raw session transcript -> structured record

When converting raw session transcripts into structured records, it’s essential to maintain clarity and usability. For instance, you might have an audio transcript processed through Whisper (a speech-to-text AI) that converts your dialogue into text. Here’s how to transform that into a structured YAML output:

1. Process Audio: Use Whisper to transcribe your session’s audio into text, capturing all spoken dialogue and key moments.
2. Extract Key Information: Identify key events, NPCs, and actions from the transcript to structure your data.
3. Format in YAML: Create a YAML structure that includes fields such as Session, Date, Summary, Entities, and Events.
4. Include Metadata: Add audio file metadata, such as duration and speaker labels, to give context to the structured output.
5. Save to Campaign Index: Store this structured record in your campaign index for future reference.

Example:

Your session might include lines like, “Elric: ‘The treasure lies beneath the old oak tree.’” The structured output could look like this:

  Session: 002
  Date: 2024-03-02
  Summary: Elric reveals the treasure’s location.
  Entities:
    - NPC: Elric
  Events:
    - Description: Elric states the treasure lies beneath the old oak tree.
  Audio Metadata:
    Duration: 5 minutes
    Speaker Labels: Elric
  Tags: [treasure, location]
  

12.2 Example: detecting contradiction between sessions

Detecting contradictions between sessions is vital for maintaining continuity in your campaign. Here’s a simple approach to identify and rectify inconsistencies:

1. Compile Session Data: Gather the structured records of multiple sessions that involve the same NPC or event.
2. Run AI Analysis: Use AI to scan for discrepancies, such as conflicting statements about what an NPC knows or has done.
3. Output Conflict Report: Generate a report that highlights contradictions, providing evidence from the relevant sessions.
4. Review Suggested Fixes: Analyze the AI’s suggestions for remediation, which might include retconning (retroactively changing), explaining memory loss, or clarifying player misunderstandings.
5. Implement Changes: Update your campaign index with the agreed-upon fixes to ensure all future sessions reflect the corrected continuity.

13. Prompts library: 8+ ready-to-use AI prompts

Having a library of ready-to-use AI prompts can significantly enhance your AI-assisted campaign prep. Here are some prompts you can utilize for various tasks:

1. Ingestion Prompt: “Convert this session transcript into structured YAML with fields: Session, Date, Summary, Entities, Events, Tags.”
2. Summarization Prompt: “Summarize this session in a one-paragraph recap, highlighting key events and NPC interactions.”
3. Contradiction Detection Prompt: “Scan the following session records for continuity errors and list any contradictions with evidence.”
4. NPC Audit Prompt: “Check the current NPC traits against previous sessions and flag any discrepancies in personality or knowledge.”
5. Timeline Merge Prompt: “Combine these session records into a chronological timeline, ensuring all events are accurately represented.”

13.1 Prompts for initial ingestion and summary

When it comes to ingesting session data and summarizing it effectively, having targeted prompts is essential. Here’s how you can structure your prompts for both single and batch ingestion:

1. Single Chunk Ingestion Prompt: “Please convert this session text into a structured YAML format with the following fields: Session, Date, Summary, Entities, Events, Tags.”
2. Batch Ingestion Prompt: “Process these multiple chunks of session data and produce a CSV file with one row per chunk, including Session ID, Date, Summary, and Tags.”

13.2 Prompts for continuity checks and NPC audits

To maintain continuity and character consistency in your campaign, specific prompts for continuity checks and NPC audits are invaluable. Here’s how you can frame these prompts:

1. NPC Continuity Check Prompt: “Evaluate the following NPC data against previous session records and identify any inconsistencies in traits or relationships.”
2. Drift Severity Scoring Prompt: “Rate the discrepancies in NPC Elric’s traits on a scale of 1 to 5, providing suggestions for remediation based on severity.”

14. Templates and file/folder conventions

Establishing clear templates and folder conventions is essential for maintaining organization in your campaign prep. Here’s how you can structure your files and folders:

1. Folder Structure: Create a scalable folder tree that separates different types of content. For example:
   • 00-Index
   • 01-Legacy
   • 02-Sessions
   • 03-NPCs
   • 04-Timeline
   • 05-Assets
   • 06-Backups
   • 07-AI-Prompts
2. File Naming Convention: Use a consistent naming format like YYYY-MM-DD_[CAT]_[ShortTitle]_[vX.X] to make chronological sorting and automation easier.

14.1 Folder layout for multi-campaign management

If you’re managing multiple campaigns, a clear folder layout is crucial. Here’s a suggested structure to keep everything organized:

1. Root Naming Pattern: Use a naming convention for the root folder like [System]_[CampaignName]_[StartYear] to clearly differentiate between campaigns.
2. README Documentation: Include a per-campaign README file that outlines the folder structure and naming conventions for new collaborators.

14.2 Note templates: session, NPC, encounter, timeline

Having structured note templates is key to efficient campaign management. Here are some templates you can use for sessions, NPCs, and encounters:

1. Session YAML Template:

       Session: [Session Number]
       Date: [Session Date]
       Summary: [Brief Summary]
       Entities: [List of NPCs]
       Events: [List of Events]
       Tags: [Keywords for Searchability]
       

2. NPC YAML Template:

       NPC: [NPC Name]
       Traits: [Character Traits]
       Relationships: [Key Relationships]
       Secrets: [Any Secrets]
       Last Updated: [Date]
       

3. Encounter Note Template:

       Encounter ID: [ID]
       Map Version: [Version]
       Enemies: [List of Enemies]
       Loot: [List of Possible Loot]
       Triggers: [Any Triggers]
       

  Session: 003
  Date: 2024-03-03
  Summary: The party confronts the dragon.
  Entities: [Dragon, Elric]
  Events: [Encounter with the dragon, Elric's betrayal]
  Tags: [combat, betrayal]
  

15. Common pitfalls and troubleshooting

When using AI-assisted campaign prep, it’s important to be aware of common pitfalls that can disrupt your workflow. Here are some mistakes to avoid and quick solutions to implement:

1. Over-Tagging: Avoid cluttering your notes with too many tags. Stick to a limited number that are meaningful and relevant.
2. Context Overflow: When chunking data, ensure that you don’t exceed the token limits of your AI tools. Aim for chunks of 2,000 to 4,000 tokens with a 200-word overlap.

If you encounter issues, such as data discrepancies or AI hallucinations (when AI generates incorrect information), quickly run a manual review of the affected sessions. Implement a version control system to track changes and revert to previous states if necessary.

15.1 Mistakes GMs make with AI-assisted prep

Many GMs fall into common traps when utilizing AI for campaign prep. Here are the top mistakes to avoid:

1. Uploading Unredacted Data: Ensure that you don’t upload player secrets or sensitive information to cloud AI services. Always anonymize player data before processing.
2. Inconsistent Naming Conventions: Stick to your established naming conventions to keep files organized and easily accessible.

15.2 Quick fixes and recovery steps

When issues arise in your AI-assisted prep, having a set of quick fixes can save you time and frustration. Here are three rapid recovery steps you can take:

1. Git Revert Command: If you find that recent changes have introduced errors, use the command git revert <commit> to roll back to a previous state.
2. Restore from Archive: If you need to recover a lost session, unzip your archive to the /restore directory and ensure the files are intact.
3. Rerun AI Reconciliation: After addressing any discrepancies, rerun your AI processes to reconcile the updated data.

16. Resources & complementary tools

To enhance your AI-assisted campaign prep, consider leveraging a variety of complementary tools. Here are some recommended resources:

1. Obsidian.md: Excellent for organizing notes and maintaining a campaign index.
2. Timeline JS: Great for visualizing your campaign’s timeline and events.
3. Game Master Toolbox: A comprehensive asset pack available on Etsy that includes over 350,000 dungeon and adventure assets, making it easy to create engaging scenes quickly. Check it out here.
4. Fantasy Map Making Kit: This kit offers 10,000 assets for creating immersive world maps and tokens, perfect for enhancing your game’s visuals. You can find it here.

16.1 How to evaluate new tools and plugins

When considering new tools for your campaign management, it’s essential to conduct a thorough evaluation. Here’s a checklist to guide your assessment:

1. Data Exportability: Ensure that the tool allows you to export data in formats like CSV or JSON, making it easy to integrate with your existing systems.
2. Privacy Policies: Review the tool’s privacy policy to confirm that your data will be handled securely and that sensitive information will be protected.
3. Integration Capabilities: Look for tools that can easily integrate with services like Zapier or Make, allowing for automation and streamlined workflows.

16.2 Selected GM Craft Tavern assets and why they help

To facilitate your campaign prep, I recommend a couple of standout assets from GM Craft Tavern that can significantly enhance your gameplay experience:

• Game Master Toolbox: This asset pack provides a vast library of over 350,000 dungeon and adventure assets, making it easy to create engaging scenes quickly. You can find it here.
• Fantasy Map Making Kit: This kit includes 10,000 assets for creating immersive world maps and tokens, perfect for enhancing your game’s visuals. You can find it here.

FAQ

• How do I safely use cloud AI to summarize sessions without exposing player secrets? Anonymize sensitive player data, flag files, and process locally.
• What’s the fastest way to turn dozens of session notes into a searchable timeline? Extract key events into a CSV format and use visualization tools.
• Which metadata fields are essential for tracking NPC continuity? Include ID, Name, Traits, Relationships, and Change Log.
• Can I use AI to detect contradictions across hundreds of sessions? Yes, compile structured records and prompt AI for inconsistencies.
• How do I link VTT maps and tokens to my campaign index? Maintain an asset registry and reference AssetIDs in session notes.

Sources

• aeons.app
• char-gen.com
• char-gen.com
• desktop.github.com