What I Built as an AI Solution Engineer Intern at O2Geeks: A Local AI Blog Generator

(A Local AI Blog Generator Agent with Ollama and Gemma)

My Journey as an AI Solution Engineer Intern at O2Geeks

Artificial Intelligence is rapidly changing how businesses create, manage, and automate content. What traditionally required hours of research, topic planning, writing, and formatting can now be partially automated using Large Language Models (LLMs).

During my internship as an AI Solution Engineer Intern at O2Geeks, I had the opportunity to work on a practical AI automation project: a Local AI Blog Generator Agent.

The goal was not simply to generate text with an AI model. The idea was to build a complete workflow where a company name could be transformed into relevant topics, SEO-friendly blog content, and downloadable files — while running the AI model locally.

The Problem

For a software company, maintaining a consistent blog requires several steps:

1. Understanding the company and its services
2. Identifying relevant topics
3. Finding content ideas
4. Writing SEO-friendly articles
5. Structuring the content
6. Saving and managing generated blogs

Doing all of this manually can be time-consuming.

I wanted to explore how an AI-based workflow could automate these steps.

Introducing the Local AI Blog Generator Agent

The project is a local AI-powered content generation application that takes a software company name as input and performs multiple tasks automatically.

The workflow is:

Company Name → Company Analysis → Topic Generation → Blog Generation → File Saving → Download

The project uses:

• Python for the core application logic
• Streamlit for the user interface
• Ollama for running the local LLM
• Gemma3:1b as the language model
• Requests for communicating with the Ollama API
• HTML & CSS for UI customization

One of the main goals was to keep the AI processing local instead of depending on external AI APIs.

1. Company Analysis

The first stage of the workflow is understanding the company.

The user enters a software company name, and the application sends a structured prompt to the local Gemma model.

The model generates information such as:

• Company Name
• Industry
• Services
• Products
• Target Audience
• Technologies
• Short Summary

This provides context that can be used as the foundation for the content generation process.

2. AI-Powered Topic Generation

After analyzing the company, the system generates relevant blog topics.

The topic-generation prompt instructs the model to produce topics that are:

• Trending
• SEO-friendly
• Unique
• Relevant to AI and software
• Useful for attracting business clients

For example, instead of simply asking an AI model:

“Give me blog topics.”

the application provides a structured prompt with specific requirements.

This is an important part of the project because prompt engineering directly affects the quality and consistency of the generated content.

3. Automated Blog Generation

Once the topics are generated, the application uses them as input for the blog-generation module.

Each topic is passed to the local Gemma model with a structured SEO writing prompt.

The generated blog follows a predefined structure:

Title

Meta Description

Focus Keywords

Introduction

Main Headings

Conclusion

Call to Action

The prompt also specifies requirements such as professional English, appropriate headings, informative content, and SEO-friendly writing.

This makes the output more structured than simply asking the model to “write a blog.”

4. Automatic File Saving

Another part of the project was handling the generated content.

Instead of displaying the blog and losing it after the session, the application automatically saves each generated blog inside an outputs directory.

For example:

outputs/
    blog1.txt
    blog2.txt
    blog3.txt

This introduced a basic file-management layer into the application.

5. ZIP Download

To make the workflow more practical, I also implemented a ZIP download feature.

After generating multiple blogs, the application collects the generated .txt files and creates:

AI_Blogs.zip

The user can then download all generated blogs together instead of downloading each file separately.

6. Building the Interface with Streamlit

For the frontend of the initial version, I used Streamlit.

The interface contains sections for:

• Company input
• Company analysis
• Suggested topics
• Generated blogs
• Individual blog downloads
• Download-all functionality
• Project information

I also worked with custom HTML and CSS to improve the visual appearance of the application.

This part of the project was particularly useful because it showed me that building an AI application is not only about the model itself. The user experience, workflow, error handling, and output management are equally important.

7. Working with a Local LLM

One of the most interesting parts of the project was using a local language model through Ollama.

Instead of sending prompts to a cloud-based API, the application communicates with the locally running Ollama server:

Python Application
       ↓
Ollama API
       ↓
Gemma3:1b
       ↓
Generated Response

This approach provides several advantages:

Privacy

The content-generation process can remain on the local machine.

No External API Dependency

The application does not require an external LLM API key for the generation process.

Local Experimentation

It makes it easier to experiment with prompts and AI workflows locally.

At the same time, working with a local model also introduced practical challenges such as generation speed, memory limitations, and request timeouts, especially when generating longer articles.

8. Debugging and Problem Solving

The project was not simply about writing code and running it once.

During development, I encountered several practical issues.

One example was the UI rendering problem with custom HTML inside Streamlit. Some HTML elements were displayed as text instead of being rendered as intended.

I also encountered timeout issues while generating long blogs through the local model.

For example:

requests.exceptions.ReadTimeout

This helped me understand an important aspect of AI application development:

A working AI model does not automatically mean the application is production-ready.

The model’s response time, prompt length, hardware resources, error handling, and application architecture all need to be considered.

Project Architecture

The current workflow can be represented as:

User
                   |
                   ↓
           Company Name Input
                   |
                   ↓
           Company Analyzer
                   |
                   ↓
             Local LLM
          (Ollama + Gemma)
                   |
                   ↓
          Topic Generation
                   |
                   ↓
            Blog Generator
                   |
                   ↓
           SEO Blog Content
                   |
          ┌────────┴────────┐
          ↓                 ↓
      Text Files        ZIP Archive
          |                 |
          └────────┬────────┘
                   ↓
               Download

The project is designed so that additional components can be integrated later without completely changing the existing workflow.

What I Learned During the Project

Working on this project as an AI Solution Engineer Intern at O2Geeks gave me practical exposure to several areas of AI engineering.

1. Prompt Engineering

I learned that the quality of an LLM response depends heavily on how the task is described.

2. Local LLM Integration

I learned how a Python application can communicate with a locally running language model through an API.

3. AI Workflow Design

The project helped me understand how multiple AI tasks can be connected into a single workflow.

4. Streamlit Development

I gained practical experience building an interactive interface for an AI application.

5. File Handling

I implemented automatic saving, individual downloads, and ZIP generation.

6. Debugging AI Applications

I learned that AI applications require a different kind of debugging because issues can come from prompts, model performance, API requests, hardware limitations, or UI integration.

Main UI screenshot:

AI-Powered Blog Generation Interface

Future Improvements

The current version is an initial working version of the system, but there is significant room for expansion.

The planned improvements include:

• FastAPI backend
• React/Nuxt frontend
• Web search integration for real-time trending topics
• Company knowledge base
• Blog history and database storage
• Automatic publishing
• Better SEO analysis
• Multi-company support
• Improved error handling
• More efficient local model configuration

The long-term goal is to move from a simple blog generator toward a more complete AI content automation agent.

My Internship Experience at O2Geeks

This project has been an important part of my experience as an AI Solution Engineer Intern at O2Geeks.

What made the experience valuable was that I was not only learning AI concepts theoretically. I was applying them to an actual workflow involving LLMs, prompt engineering, APIs, automation, UI development, debugging, and file management.

The project also showed me the difference between experimenting with an AI model and building an actual AI application.

An AI model can generate a response in a few lines of code, but creating a useful application around that model requires much more:

Understanding the problem → Designing the workflow → Integrating the model → Handling outputs → Building the interface → Testing → Debugging → Improving the system

That has been one of the biggest lessons from this internship.

Conclusion

The Local AI Blog Generator Agent demonstrates how a locally hosted LLM can be integrated into a practical business-oriented automation workflow.

From company analysis and topic generation to SEO blog creation, file management, and downloads, the project brings multiple components together into a single application.

More importantly, the project has given me hands-on experience as an AI Solution Engineer Intern at O2Geeks, allowing me to move beyond theoretical AI concepts and work on the practical challenges involved in building AI-powered solutions.

This is only the beginning of the project. With FastAPI, a modern frontend, web search, and automated publishing, the system can eventually evolve into a more advanced AI content automation platform.

Building with AI is not just about making a model generate an answer — it is about turning that capability into a reliable solution.