DEV Community: Veditha

RepurposeAI- a local content repurposer built on Ollama

Veditha — Sat, 17 Oct 2026 09:15:29 +0000

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

RepurposeAI: Repurpose Content with Local AI Models

What I Built

RepurposeAI converts a blog post or video transcript into platform-specific content for Twitter/X, LinkedIn, newsletters, Instagram, and Reddit.

Paste your source content, choose a format, and watch the output stream directly to the page, token by token, from a model running on your local machine.

The intended user is someone who publishes regularly across multiple platforms and has to manually rewrite the same content several times a week. It's a repetitive task, and many content tools offer AI-powered alternatives through paid subscriptions.

RepurposeAI takes a different approach: it uses a local model through Ollama instead of a paid AI API. The trade-off is that users must install Ollama and download a model themselves. Once the model is available locally, there are no per-generation API charges, and the content sent to the model stays on the user's machine.

Demo

Run Locally

Prerequisites: Node.js and Ollama.

Pull a model and start Ollama:

ollama pull llama3.2
ollama serve

In a separate terminal, clone and run the project:

git clone https://github.com/Veditha08/repurpose-ai
cd repurpose-ai
npm install
npm run dev

Open http://localhost:5173 in your browser.

Code and Architecture

The project uses a small React frontend with a dedicated module for communicating with Ollama.

src/
├── App.jsx       # UI and application state
├── ollama.js     # Ollama client and prompt templates
├── index.css     # Styles
└── main.jsx      # Application entry point

Streaming Responses from Ollama

The core of the Ollama integration is an asynchronous generator that reads the streaming NDJSON response from the API.

export async function* streamGenerate(model, prompt, signal) {
  const res = await fetch('http://localhost:11434/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ model, prompt, stream: true }),
    signal,
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;

    const lines = decoder
      .decode(value, { stream: true })
      .split('\n')
      .filter(Boolean);

    for (const line of lines) {
      try {
        const obj = JSON.parse(line);

        if (obj.response) yield obj.response;
        if (obj.done) return;
      } catch {
        // Ignore malformed or incomplete lines.
      }
    }
  }
}

The React application consumes the generator using for await...of and appends incoming text to the output state as it arrives. This makes the generation process visible instead of keeping the user waiting for the entire response.

There is no application backend. The browser communicates directly with Ollama running on the same machine.

Each output format has its own prompt template. For example, the newsletter template requests a subject line, an introductory paragraph, three bullet points, and a call-to-action paragraph. The prompts also incorporate the selected niche, tone, and output language to tailor the result to the intended audience.

How It Works

Ollama: Runs local language models and exposes a REST API for generation and model discovery.
Open-weight models: Users can select from models installed in Ollama, such as Llama 3.2, Qwen 2.5, or Mistral, provided the selected model is compatible with the requested generation.
React + Vite: Powers the frontend and development server. The application does not require its own backend, database, or authentication layer.
localStorage: Stores generation history in the browser, with up to 30 entries.

The architecture is intentionally simple:

React frontend
     |
     | POST /api/generate
     v
Ollama running locally
     |
     | Streaming response
     v
React state → UI updates

Why Does Open Innovation Matter?

Building this project with open-weight models made three things possible.

1. Cost Structure

Hosted AI APIs can charge per token or request. For someone who frequently repurposes content, those costs can accumulate.

With local inference, there are no per-generation API charges. The trade-off is that users need suitable hardware, and running models still consumes electricity and other computing resources.

2. Data Control

Content being repurposed may belong to clients, contain unreleased material, or be subject to confidentiality requirements.

Because RepurposeAI sends generation requests to Ollama running locally rather than to a hosted AI inference provider, the source content does not need to be sent to a third-party AI API. This reduces external data exposure, although the privacy of the overall setup also depends on the user's environment and configuration.

3. Model Flexibility

Different models can produce different results depending on the content, niche, and task.

With Ollama, users can switch between compatible installed models without integrating a new hosted AI API or managing separate API credentials. The application discovers available models and lets users choose which one to use.

Limitations and Trade-offs

The main limitation is setup complexity.

Ollama is relatively straightforward to install, but asking a non-technical user to download a model, start the local service, and configure their environment introduces friction. Model performance and generation speed also depend on the chosen model and available hardware.

A hosted-API version could be easier to access, but it would introduce different costs and data-handling considerations.

For this project, I chose local inference to explore how open-weight models can make content-generation tools more accessible to people who prefer to run AI on their own machines.

RepurposeAI — a local content repurposer built on Ollama

Veditha — Sat, 17 Oct 2026 09:12:05 +0000

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

RepurposeAI: Repurpose Content with Local AI Models

What I Built

RepurposeAI converts a blog post or video transcript into platform-specific content for Twitter/X, LinkedIn, newsletters, Instagram, and Reddit.

Paste your source content, choose a format, and watch the output stream directly to the page, token by token, from a model running on your local machine.

Demo

Run Locally

Prerequisites: Node.js and Ollama.

Pull a model and start Ollama:

ollama pull llama3.2
ollama serve

In a separate terminal, clone and run the project:

git clone https://github.com/Veditha08/repurpose-ai
cd repurpose-ai
npm install
npm run dev

Open http://localhost:5173 in your browser.

Code and Architecture

The project uses a small React frontend with a dedicated module for communicating with Ollama.

src/
├── App.jsx       # UI and application state
├── ollama.js     # Ollama client and prompt templates
├── index.css     # Styles
└── main.jsx      # Application entry point

Streaming Responses from Ollama

The core of the Ollama integration is an asynchronous generator that reads the streaming NDJSON response from the API.

export async function* streamGenerate(model, prompt, signal) {
  const res = await fetch('http://localhost:11434/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ model, prompt, stream: true }),
    signal,
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;

    const lines = decoder
      .decode(value, { stream: true })
      .split('\n')
      .filter(Boolean);

    for (const line of lines) {
      try {
        const obj = JSON.parse(line);

        if (obj.response) yield obj.response;
        if (obj.done) return;
      } catch {
        // Ignore malformed or incomplete lines.
      }
    }
  }
}

There is no application backend. The browser communicates directly with Ollama running on the same machine.

How It Works

Ollama: Runs local language models and exposes a REST API for generation and model discovery.
Open-weight models: Users can select from models installed in Ollama, such as Llama 3.2, Qwen 2.5, or Mistral, provided the selected model is compatible with the requested generation.
React + Vite: Powers the frontend and development server. The application does not require its own backend, database, or authentication layer.
localStorage: Stores generation history in the browser, with up to 30 entries.

The architecture is intentionally simple:

React frontend
     |
     | POST /api/generate
     v
Ollama running locally
     |
     | Streaming response
     v
React state → UI updates

Why Does Open Innovation Matter?

Building this project with open-weight models made three things possible.

1. Cost Structure

Hosted AI APIs can charge per token or request. For someone who frequently repurposes content, those costs can accumulate.

With local inference, there are no per-generation API charges. The trade-off is that users need suitable hardware, and running models still consumes electricity and other computing resources.

2. Data Control

Content being repurposed may belong to clients, contain unreleased material, or be subject to confidentiality requirements.

3. Model Flexibility

Different models can produce different results depending on the content, niche, and task.

Limitations and Trade-offs

The main limitation is setup complexity.

A hosted-API version could be easier to access, but it would introduce different costs and data-handling considerations.

For this project, I chose local inference to explore how open-weight models can make content-generation tools more accessible to people who prefer to run AI on their own machines.

TraiLens: An Offline-First AI Nature Journal

Veditha — Tue, 06 Oct 2026 16:10:35 +0000

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

What I Built

I built TraiLens, a local Python tool that automatically generates a Markdown nature journal from your hiking photos using a local open-weight vision model.

Most outdoor apps require you to stare at your screen on the trail. TraiLens flips that: it encourages you to put your phone on airplane mode. You go outside, enjoy the trek, and simply snap photos of interesting plants, geology, or landscapes. When you get home, you drop the photos into a folder on your laptop. TraiLens runs them through an open-weight vision model and generates a beautiful, documented field diary of what you saw, complete with EXIF metadata extraction.

The screen time happens after the hike, not during it.

Demo

Here is TrailLens running locally and analyzing my photos completely offline:

And here is the beautiful field guide it automatically generates:

Code

Veditha08 / trailens

🌲 TraiLens

An offline-first, local-inference field naturalist journal built for the Hacktoberfest "Touch Grass" AI Challenge.

TrailLens eliminates screen time on the trail. Put your phone in airplane mode, hike screen-free, and take photos of flora, fauna, and geology. When you return, TrailLens processes your photos locally using Moondream via Ollama, extracting EXIF metadata and generating an automated Markdown field journal with zero cloud API dependencies.

Features

100% Offline & Private: Zero telemetry or cloud calls. GPS and photos stay on your device.
Local Vision Inference: Powered by Moondream via Ollama.
EXIF Extraction: Automatically retrieves capture timestamps and GPS markers.

Quickstart

Install Ollama and pull the model:
```
ollama pull moondream
```

View on GitHub

How I Built It

TrailLens is built in Python and relies entirely on local edge inference.

Instead of sending my photos to a paid cloud API, I used Ollama to run Moondream (a lightweight, highly capable open-source vision model). The Python script loops through a local directory of images, extracts the GPS and timestamp EXIF data using the Pillow library, and then prompts the local Moondream model to act as a master naturalist, identifying the flora and terrain. Finally, it compiles everything into a formatted Markdown file (TRAIL_JOURNAL.md).

Why Does Open Innovation Matter?

This project only makes sense with open-source AI:

Total Privacy: Hiking photos contain metadata and exact GPS coordinates of where you have been. Sending a camera roll to a closed API is a massive privacy risk. Running Moondream locally guarantees your location history never leaves your laptop.
Zero Cost: Passing high-res images to a cloud vision API costs money per token. A heavy hiker might take 100 photos on a weekend trip. Local inference makes processing bulk image data completely free.
Disconnection: Because the processing happens locally on my laptop after the hike, I am not tempted to look for a cell signal on the trail to see what an app thinks I'm looking at. Open, offline models let nature actually be nature.

Prize Categories

Grand Prize Track (Touch Grass): Engineered specifically to get people off screens while on the trail, utilizing local inference to process the data only after the outdoor experience is finished.
Best Use of Local Inference: The core of the project relies on Ollama and Moondream to analyze images without an internet connection.