Building an AI-Powered Ball Story Generator

- 3 mins read

Recently, I embarked on an interesting project: creating an AI-powered system that generates humorous stories and satirical news articles about various types of balls. The result is A Balling Site, where you can find these AI-generated tales.

The Concept

The idea was to create a system that could:

  1. Generate engaging stories and news articles about different types of balls
  2. Create AI-generated images for both the main content and specific scenes
  3. Automatically format and deploy everything to a Hugo static site

Technical Stack

The system uses a combination of modern tools and APIs:

  • LLM Providers:
    • Ollama (primary) for story generation
    • OpenAI (optional) as a fallback
  • Image Generation:
    • ComfyUI (primary) for high-quality images
    • DALL-E (optional) as an alternative
  • Static Site: Hugo for content management and deployment

Key Challenges

1. Managing Multiple AI Providers

One of the main challenges was creating a flexible system that could work with different AI providers. Here’s how we handled the LLM provider selection:

class LLMProvider:
    """Base class for LLM providers."""
    
    def generate_content(self, prompt: str) -> str:
        """Generate content using the provider."""
        raise NotImplementedError

class OllamaProvider(LLMProvider):
    def generate_content(self, prompt: str) -> str:
        """Generate content using Ollama API."""
        response = requests.post(
            f"{settings.OLLAMA_API_URL}/api/generate",
            json={
                "model": settings.OLLAMA_MODEL,
                "prompt": prompt,
                "stream": False,
                "format": "json"
            }
        )
        return response.json()["response"]

2. Image Generation and Scene Placement

Another challenge was ensuring that the generated images matched the story content and were placed appropriately. We solved this by:

  1. Using a [SCENE] marker in the generated content
  2. Creating two types of images:
    • Main image for the story header
    • Scene image for specific story moments
def create_blog_post(data: Dict[str, Any], image_path: Optional[str] = None, scene_image_path: Optional[str] = None, content_type: str = "story") -> str:
    # Process the content to insert the scene image
    content_parts = content.split('[SCENE]')
    content_with_image = content_parts[0]
    if len(content_parts) > 1 and scene_image_path:
        content_with_image += f"\n\n[![scene]({scene_image_path})]({date}-{slug}-{timestamp})\n\n" + content_parts[1]

3. Content Cleaning and Formatting

The AI models sometimes return content with JSON artifacts or code blocks. We implemented robust cleaning functions:

def clean_content(content: str, content_type: str = 'story') -> str:
    """Clean up story/article content by removing JSON artifacts and extra whitespace."""
    # Remove any code blocks and JSON artifacts
    content = re.sub(r'```.*?```', '', content, flags=re.DOTALL)
    content = re.sub(r'\{.*?\}', '', content, flags=re.DOTALL)
    content = re.sub(r'```json\s*\{.*?\}```', '', content, flags=re.DOTALL)
    
    # Remove any extra newlines
    content = re.sub(r'\n{3,}', '\n\n', content)
    
    return content.strip()

Interesting Findings

  1. Ollama’s JSON Output: While Ollama is great for creative writing, getting consistent JSON output was challenging. We had to implement fallback mechanisms and robust parsing.

  2. Image Generation Timing: ComfyUI image generation can take several seconds. We implemented proper waiting mechanisms and error handling to ensure reliability.

  3. Content Structure: The AI models sometimes needed explicit instructions about content structure. We found that detailed prompts with examples worked best.

The Result

The system now generates engaging content like this:

---
title: "Great-Basketball"
date: 2025-03-30
draft: false
categories: ["story"]
tags: ['basketball', 'humor', 'kids', 'ollama', 'llama3.1:8b', 'comfyui']
---

[![image](/images/comfyui-090916.png)](2025-03-30-great-basketball-090951)

It was a typical Tuesday afternoon at Springdale Elementary when chaos erupted in the school gym...

[![scene](/images/comfyui-090951.png)](2025-03-30-great-basketball-090951)

But little did they know, Benny had bigger plans...

Future Improvements

  1. Better Error Handling: Implement more robust error recovery for API failures
  2. Content Quality: Add content validation and filtering
  3. Image Quality: Implement image quality checks and regeneration if needed
  4. Performance: Optimize the image generation process

Conclusion

Building this system was a great learning experience in working with multiple AI providers and handling their quirks. The result is a fun, automated content generation system that creates engaging stories and articles about balls.

You can check out the results at balls.no, and the source code is available on GitHub.

This project demonstrates how we can combine different AI technologies to create engaging content. While there were challenges in managing multiple providers and ensuring consistent output, the result is a fun and interesting experiment in AI-powered content generation.