DEV Community: Arthur Azevedo

AdMuse: Local AI for Promotional Content for Small Creative Businesses

Arthur Azevedo — Mon, 19 Oct 2026 00:21:07 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

Artists and small creative businesses often have to manage everything themselves: creating products, serving customers, and promoting their work. Writing advertisements and protecting original artwork can become additional challenges in an already busy routine.

That's why I built AdMuse, an open-source AI-powered promotional assistant designed for artists, independent creators, and small creative businesses.

AdMuse helps users generate promotional content by providing information about a product or service, target audience, promotional channel, writing style, language, and marketing objective. The application generates a title, promotional text, a call to action, and optional hashtags.

It also includes a promotion history and a watermarking feature that lets users add contact information or a logo to artwork images.

The idea came from someone close to me: my sister runs a small graphics and printing business. I wanted to build something practical that could help her promote her work more easily and add a layer of protection to her artwork.

Instead of building around an abstract use case, I had a real person and real needs in mind from the beginning.

Demo

Here's a demonstration of AdMuse in action, showcasing its promotional content generation and watermarking features.

Code

GitHub repository: ArthurHebertt/AdMuse

AdMuse is built with Java and Spring Boot, uses PostgreSQL for persistence, and integrates local AI inference through Ollama.

How I Built It

I built AdMuse using Java and Spring Boot, integrating the open-weight qwen3:4b-q4_K_M model through Ollama.

Instead of depending on a hosted AI API for content generation, the application sends requests to a model running locally through Ollama. The generated result is structured into fields that the application can present to the user.

The main features include:

Promotional content generation: Generate titles, promotional text, calls to action, and optional hashtags.
Multiple writing styles: Choose between professional, casual, creative, elegant, and fun.
Multilingual generation: Create content in Brazilian Portuguese, English, or Spanish.
Promotion history: Save and retrieve previously generated promotions.
Artwork watermarking: Add contact information or a logo to artwork images.

One important design consideration was preventing the AI from inventing business information. For example, when a user does not provide a price, the generated advertisement should not fabricate one.

I also kept content generation separate from saving. Users can review generated content before deciding whether to store it.

Building AdMuse brought together backend development, database persistence, AI integration, and a practical user interface in one project.

Why Does Open Innovation Matter?

I wanted to explore how open AI could make practical tools more accessible to small businesses and independent creators.

By using an open-weight model through local inference, AdMuse can generate promotional content without requiring a paid, hosted AI API for that task. It also gives developers the freedom to experiment with models and adapt their applications without depending entirely on a proprietary AI provider.

Local inference can help keep business information on the user's machine rather than sending it to an external AI provider, provided the application and its surrounding infrastructure are configured accordingly.

For me, open innovation is about more than access to a model. It is about giving developers the opportunity to build useful tools, learn from real users, and explore solutions that might otherwise be too expensive or difficult to experiment with.

My First User

My first user was also the person who inspired AdMuse: my sister, who runs a small graphics and printing business.

After testing the application, she shared this feedback:

"I loved how I could create my advertisement. There are many useful features for promoting my business. I recommend it!"

She later explained that AdMuse met her two main needs: helping her generate advertisements and adding watermarks to her artwork to help discourage unauthorized use.

The watermarking feature mattered to her because she wanted a practical way to make her artwork less vulnerable to being reused without permission. A watermark cannot guarantee protection against theft, but it can help identify the creator and discourage some unauthorized uses.

Her feedback was an important milestone for me. It showed that the features I had prioritized were relevant to the person I originally wanted to help.

AdMuse is still an early-stage project, but having its first intended user test it and confirm that the main features addressed her needs made the project feel much more tangible.

Final Thoughts

AdMuse started with a simple question: could I use open-source AI to build something genuinely useful for a small creative business?

Working on this project allowed me to combine Java, Spring Boot, PostgreSQL, and local AI inference while focusing on a real-world problem rather than building a purely theoretical demo.

The experience also reminded me of the importance of getting feedback early. A feature may look good from a developer's perspective, but hearing from the person who will actually use it helps determine whether it solves the right problem.

There is still room to improve AdMuse, but I now have a working project, a demonstration, and feedback from its first user.

Thanks for reading! I'd love to hear how other developers are using open AI models to build practical tools for independent creators and small businesses.

🌱 Touch Grass API: AI-Powered Missions to Get You Outside

Arthur Azevedo — Mon, 12 Oct 2026 02:09:07 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What if AI could help you spend less time looking at a screen and more time enjoying the world outside?

That question inspired Touch Grass API, a Java project that uses locally running AI to generate outdoor missions and encourage people to take a break from their screens.

Instead of using AI to keep people online for longer, I wanted to explore a different idea: using technology to help people disconnect.

What I Built

Touch Grass API generates outdoor missions with the help of an AI model running locally through Ollama.

Each mission includes a title, a motivational message, a suggested activity, an estimated duration, and a difficulty level. Users can generate new missions, browse their missions, and mark activities as completed through a web interface backed by a REST API.

The project is built for anyone who wants a simple way to break their screen-time routine, discover outdoor activities, and make more room for real-world experiences.

The main idea is simple: use AI to inspire action outside the screen, not another reason to stay in front of it.

Demo

🎥 Watch Touch Grass API in action:

The demonstration shows the application running locally, generating outdoor missions and managing them through its web interface.

The project currently runs locally and does not have a publicly hosted demo.

Code

💻 Explore the source code on GitHub:

ArthurHebertt/Touch-grass-api

The repository includes the source code, project documentation, and instructions for running the application locally.

How I Built It

I built Touch Grass API using Java 17 and Spring Boot, with a focus on backend development, clean separation of responsibilities, and practical integration with AI.

The main technologies are:

Java 17 — application logic.
Spring Boot — REST API and application infrastructure.
Spring Data JPA — persistence.
H2 Database — local database storage.
Thymeleaf — web interface.
Ollama + Qwen3 — local AI inference and mission generation.
Maven — dependency management and builds.

One of my most important architectural decisions was using hexagonal architecture. I separated the domain, application use cases, and infrastructure adapters to keep the business rules independent of the technologies used to run the application.

For AI integration, I implemented an adapter that communicates with Ollama's local API. The application sends a request to the locally running model, receives the generated content, and uses it to create an outdoor mission.

This project gave me an opportunity to practice backend concepts such as REST endpoints, validation, persistence, exception handling, and automated testing while exploring how AI can be integrated into a Java application.

Why Does Open Innovation Matter?

Open innovation was essential to making this project possible.

By using Ollama with the Qwen3 model, I could experiment with AI inference on my own machine instead of depending on a hosted, closed AI API for every generation.

This approach offers several advantages:

Local control: prompts can be processed locally rather than being sent to an external AI provider.
Flexibility: I can experiment with different compatible models and adjust the application as the project evolves.
Accessibility for experimentation: I could build and test the integration without needing a paid hosted AI API.
Learning and transparency: working with open-weight models and open-source tooling gave me a more hands-on understanding of how AI fits into an application.

Local inference does have trade-offs. Performance depends on the available hardware, and downloading the model initially requires obtaining the model files. Running inference locally also does not automatically make every component of an application open source.

What mattered most to me was having the freedom to experiment, learn, and build around a model I could run locally.

That freedom helped me turn a small idea into a working application while keeping the AI component under my control.

More importantly, it gave me a chance to explore a different use of AI: encouraging people to spend less time online and more time in the real world.

Final Thoughts 🌿

Touch Grass API started as a project to practice Java backend development, but it became a way to explore how technology can support healthier habits.

I learned more about structuring a Spring Boot application, integrating local AI, and connecting a technical implementation to a real-world purpose.

There is still plenty of room to improve the project, but the core idea is already there: make technology a starting point for an outdoor experience rather than the destination itself.

Sometimes, the best thing an application can do is give you a reason to close your laptop and go outside.

What kind of outdoor mission would you like an AI to suggest for you?

java #springboot #opensource #ai