Dynamic Context Stacking with ChatGPT: Enhancing Automated Content Generation

In AI-driven content generation, context is everything. To generate relevant and engaging outputs, especially in applications where continuity or specific knowledge is required, it’s important to feed the model the right background information.

In my ongoing project with Navarre Savory Safari, an AI-powered zoo experience, I’ve been using dynamic context stacking to provide ChatGPT with tailored information for different tasks. This approach enables me to generate highly contextualized social media posts and image prompts by stacking multiple context files, each representing different types of data, on top of one another. This article will explain how you can use context files to provide context dynamically and conditionally with the ChatGPT API.

Using Context Stacking for Prompt Generation

In my case, I have different context files, in ChatGPT supported JSON format, that hold specific context for various aspects of the zoo. For example:

• Common Context: Most basic facts about the zoo, such as high-level description and purpose.
• General Context: Expanded description of our zoo and what you may find if you visit.
• Event Context: Information about historical. current, and upcoming events.
• Attraction Context: Details about specific attractions, like the Giraffe Milk Experience or Otter Jerky Tasting Flight.
• Employee Context: Data about employees, such as the zookeepers or chefs and their unique roles.

When generating content, I start by loading the common context, and based on what I’m trying to generate (e.g., a post about an event or an employee), I stack additional files on top. This allows me to provide ChatGPT with the relevant background information it needs to generate coherent and engaging content.

ChatGPT and Context Files: An Example

Here’s how I structure the JSON files that are loaded into the API call for the prompt. Let’s look at some abbreviated examples:

Common Context (context_common.json):

[
    {
        "user_message": "Navarre Savory Safari is the world's first tasting zoo, where visitors can sample jerky made from the very animals on display. Each animal's jerky is available via a vending machine located in front of its enclosure, allowing guests to taste the animals as they tour the zoo. ",
    }
]        

General Context (context_general.json):

[
    {
        "user_message": "Navarre Savory Safari is the world's first tasting zoo, offering guests the opportunity to explore exotic wildlife in an unprecedented way. With a focus on both culinary and animal experiences, the zoo invites visitors to enjoy not just the sight of animals but also dishes inspired by them.",
    }
]        

Event Context (context_event.json):

?[
    {
        "user_message": "Here's a list of events that we either have had or are ongoing at Navarre Savory Safari:\nKickoff Cookoff: Tailgate Tastings: Every Saturday during college football season, guests can enjoy exotic Game Day Jerky Platters at the Expedition Café, featuring dishes like Alligator Gatorade Glaze and Owl Wing Wings, inspired by college football mascots.",
    }
]        

Employee Context (context_employee.json):

[
    {
        "user_message": "Here's some information about current employees at Navarre Savory Safari:\nEwan is the master chef, known for his extraordinary seasoning skills, including his renowned ring-tailed lemur jerky, flavored with secret spices from Scotland.",
    }
]
        

Prompts: Each prompt file contains a specific request. For example, the prompt for an event might look like this:

In the style of dark humor, create a social media post for our zoo. Be creative and come up with an event. Please also include a prompt to generate an image, start it with "an amateur photo of" and enclose it in double brackets and nothing else.        

Ultimately, this approach let's me automate while still maintaining creativity by combining different context with different prompts or even letting ChatGPT come up with a prompt and randomize context. In my implementation, I simply use arguments to pull in the data I need.

Step-by-Step: How to Stack Context Files for the ChatGPT API

1. Load and Stack Context Files In this example, we dynamically load multiple JSON files representing different contexts (such as general, event-specific, or employee-specific) and combine them. The context files provide background information to ensure that ChatGPT has the relevant knowledge when generating content.

Here’s how we load and stack the context files:

In the actual implementation, I specify the common context file and an additional context file (e.g., event-specific) that needs to be merged on top of the common context:

2. Load the Prompt from a File I’ve also made it easy to load a prompt from a text file by providing a filename through a command-line argument. This prompt provides instructions to ChatGPT on what kind of content you want it to generate.

For example, if you’re generating content for an event, you could have a corresponding prompt_event.txt file that ChatGPT will use to guide its content generation and load this from arguments:

generate_data.py    -context general -prompt event        

3. Generate the Response The core of the script is generating a response from the ChatGPT API, with logic to handle retries and timeouts, ensuring that the call is robust even if it occasionally fails or times out.

Example of Dynamic Context in Action Suppose I want to generate a social media post for a new event. Here’s how the prompt might look:

1. Prompt: "In the style of dark humor, create a social media post for our zoo. Come up with an event and be creative!"
2. Loaded Context: Common Context: General zoo information. Event Context: Details about previous events.
3. Generated Post: Post: “Join us this Saturday for the Kickoff Cookoff at Navarre Savory Safari, where college football meets exotic jerky. Come try our Game Day Platters, including Alligator Gatorade Glaze and Owl Wing Wings. A taste of the wild that’s perfect for game day!” Image Prompt: [[an amateur photo of happy guests holding exotic jerky platters, enjoying a tailgate party at Navarre Savory Safari’s outdoor café]]

...and just for fun, here's the complete, actual, 100% autonomous post on one of the target platforms (Facebook):

Best Practices for Dynamic Context Stacking

1. Modularity: Organize your context files based on themes (general, events, employees, attractions) to allow flexibility in stacking based on the task at hand.
2. Relevance: Ensure that only relevant context is stacked. Overloading the API with unnecessary information can lead to less focused responses and performance issues. Repeating context will result in repeated themes and bias.
3. Performance: Monitor token usage. While stacking contexts is powerful, both the input and output of the API call count toward token limits, so it’s important to keep your contexts concise.

By stacking different context files dynamically based on the task, you can make your ChatGPT API calls more intelligent and context-aware. This approach not only enhances the relevance of generated content but also allows for modular, scalable prompt engineering. Whether you're generating social media content or other types of outputs, stacking context files is a powerful method to provide tailored, engaging, and coherent results.

A Note on Scaling Up...

While stacking context files is an effective solution for lightweight implementations, it becomes impractical for handling large and complex knowledge bases. As data grows, managing context manually introduces performance limitations such as API token constraints. For larger systems, more sophisticated approaches are needed, including knowledge graphs for structured, dynamic querying, retrieval-augmented generation (RAG) for real-time context retrieval, vectorized semantic search to find context based on meaning, and long-term memory systems that allow AI to "remember" and efficiently recall information over time. These solutions enable scalable, context-aware AI systems that maintain performance.

Final Thoughts: Building Autonomous Social Media Systems

What I've really built with this approach is a lightweight yet effective solution for autonomous social media content generation. By dynamically stacking different context files (whether for an imaginary zoo or a real-world entity), I’ve been able to automate the creation of engaging, tailored posts and image prompts with minimal manual intervention, at very low cost.

This method allows for modularity and flexibility, ensuring that the generated content stays relevant, creative, and contextually accurate—all essential elements for running an effective social media strategy. Whether you’re managing a small-scale project or just starting with AI-driven automation, this approach provides a solid foundation.