# ClassifAI: a WordPress plugin that routes content tasks to OpenAI, Azure, Gemini, Watson or local Ollama

> ClassifAI is a GPL-2.0 WordPress plugin from 10up that connects post editing, media and search to external AI providers. It is a connector and an admin UI, not a model, and the provider you pick decides what it can do.

**10up/classifai** — Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence.

- Repository: https://github.com/10up/classifai
- Website: https://classifaiplugin.com
- Stars: 710 · Forks: 65
- Language: PHP
- License: GPL-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/10up-classifai

## What ClassifAI actually is, and who it is for

ClassifAI is a WordPress plugin, not a service and not a model. Its job is to sit between your WordPress install and a set of external AI providers, then expose the results as normal WordPress objects: excerpts, titles, taxonomy terms, featured images, comment statuses, audio attachments. The README describes the intent as tapping into cloud services to "augment your WordPress-powered websites", and the feature list is a catalogue of editor tasks rather than a model card.

The audience is narrower than the tagline suggests. This is for site owners and agencies running WordPress who want AI-assisted editing but do not want to write their own provider clients, retry logic and settings screens. It is not for people who want to run inference themselves, and it is not a general-purpose AI framework. If your content lives outside WordPress, the plugin has nothing to attach to.

One structural detail matters more than any feature: the plugin is provider-agnostic by design, and different features support different providers. Summaries and titles work with OpenAI, Azure OpenAI, Gemini, xAI Grok or local Ollama. Key takeaways, by contrast, list only OpenAI, Azure OpenAI and Ollama. Moderation is OpenAI only. Text to speech spans Azure, Amazon Polly, OpenAI and ElevenLabs. That asymmetry is the single most important thing to check before installing.

## How the plugin routes a post through a provider

The repository layout tells you the shape of the thing. There is a classifai.php entry point at the root, an includes/ directory holding the PHP classes, a src/ directory for the JavaScript and TypeScript that builds the editor and admin UI, and a config.php. The build is a standard WordPress script pipeline: package.json defines start and build as wp-scripts start and wp-scripts build, so front-end assets are compiled from src/ rather than shipped as hand-written files.

Functionally, the flow is: a feature is enabled in the admin settings, a provider and credentials are selected for it, and the plugin then either runs at save time, on demand from the editor, or on front-end request depending on the feature. Excerpt generation writes into the post excerpt field. Key takeaways render at the top of a post. Classification writes taxonomy terms. The smart 404 and the similar-terms merge both depend on embeddings, and both are documented as requiring ElasticPress in combination with OpenAI embeddings or Azure OpenAI. That dependency is not optional decoration: without ElasticPress there is no vector store for the plugin to query.

The consequence is that ClassifAI is a thin orchestration layer over someone else's API. Latency, rate limits, pricing and model behaviour belong to the provider. The plugin's own surface area is settings, prompts, hooks and the mapping of responses back into WordPress fields.

## Installing ClassifAI and generating your first excerpt

The README points to classifaiplugin.com for feature information and to the documentation site at 10up.github.io/classifai. Installation follows the normal WordPress plugin route: the plugin is distributed through the WordPress plugin directory, so you can install it from the admin Plugins screen or with WP-CLI. The repository also ships a WordPress Playground blueprint, which the README links as a demo badge, so you can try the plugin in a browser before touching a real site.

For a local development environment, the repository uses wp-env. These are the scripts defined in package.json:

```bash
npm install
npm run env:start
```

The first command installs the Node dependencies, the second starts the wp-env WordPress instance defined by .wp-env.json. To build the assets from src/ you run:

```bash
npm run build
```

On a production site the equivalent is installing the released plugin ZIP and activating it. Once active, open the ClassifAI settings screen, pick a feature such as excerpt generation, choose a provider, and paste the API credentials for that provider. Only after credentials are saved does the feature become usable.

With a text-generation provider configured, the workflow is: write a post, then trigger excerpt generation from the editor. According to the feature list, the generated summary is stored as the post excerpt. If you chose a provider that the feature does not list, the option will not be available for that feature, which is the plugin's way of enforcing the provider matrix.

## Where ClassifAI stops being the right tool

The provider matrix is the first real limitation, and it is not a bug. Features are wired to specific providers, so a team standardised on Gemini cannot use Gemini for key takeaways, and a team on Ollama cannot use it for moderation or text to speech. Choosing a provider is therefore a per-feature decision, and the plugin gives you no way to make one provider the default for everything.

The second limitation is data flow. Every feature except local Ollama and a local Stable Diffusion instance sends content to a third party. Post text, audio files, images and comment bodies leave your server. The README lists no redaction step, no content filtering before transmission and no self-hosted alternative for moderation, transcription or text to speech. For sites handling regulated or confidential material, that alone may rule the plugin out.

The third is the ElasticPress coupling. The smart 404 page and the similar-terms merge are documented as requiring ElasticPress alongside an embeddings provider. If you do not already run ElasticPress, those two features imply a second piece of infrastructure, not just an API key. The README also notes a behavioural limit on the term merge: it compares top-level terms only, and merging a term that has children promotes those children to top level, which is default WordPress behaviour rather than something the plugin controls.

Finally, the README does not document rollback, per-feature cost tracking or a dry-run mode. Generation writes into post fields and taxonomy terms; there is no described undo for a batch of AI-assigned terms.

## How it compares with calling the OpenAI API from a small mu-plugin

The obvious alternative is not another WordPress plugin. It is a short mu-plugin that calls the provider API directly on save_post, writes the result into the excerpt, and stores the key in wp-config.php. That approach gives you exactly one feature, no admin UI, no provider abstraction and complete control over what is sent and when.

The difference in approach is where the complexity lives. A hand-rolled mu-plugin puts provider selection, prompt versioning, error handling and retries in your codebase, and you own every change the provider makes. ClassifAI puts that in the plugin, which means the plugin's release cycle, not yours, decides when a new provider or model is supported. The trade is maintenance for control. If you need one feature and one provider, the mu-plugin is smaller and easier to audit. If you need several features across several providers, with an admin UI that non-developers can configure, rebuilding ClassifAI is not a weekend task.

A second comparison point is the local path. ClassifAI supports Ollama for several text features and Stable Diffusion for image generation, which keeps inference on your own hardware. A direct integration could do the same, but you would still be writing the WordPress-side plumbing that the plugin already ships.

## Maintenance, licensing and what a version bump costs

The repository is not archived, and the last push was on 2026-09-10, so the codebase is being touched. Recent releases are 3.9.0 on 2026-07-15 and 3.8.0 on 2026-03-20, with a ci-artifacts tag on 2026-06-03 carrying WordPress Playground testing ZIPs. That cadence suggests a minor release roughly every few months, with the develop branch as the integration point.

Upgrade cost is dominated by the provider matrix, not by the plugin code. When a provider changes a model name or deprecates an endpoint, the plugin has to release a fix, and you have to apply it. The plugin also declares a WordPress tested-up-to version in its README badge, currently v6.9, so a WordPress major release is a point where you should re-check compatibility before updating.

Licensing: the repository LICENSE.md and package.json both point to GPL-2.0 (the package.json field reads GPL-2.0-or-later). That is the same licence family as WordPress itself, which is the expected choice for a plugin distributed through the directory. It says nothing about the terms of the AI providers you connect to. Those are separate agreements with OpenAI, Microsoft, Google, IBM, Amazon, ElevenLabs, xAI or Together AI, and the plugin's licence does not extend to them. This is not legal advice; check the provider terms against your own data handling obligations.

## Conclusion

Adopt ClassifAI if you run WordPress and want AI features inside the editor without building provider plumbing yourself, and if you accept that content leaves your server for every provider except Ollama and a local Stable Diffusion instance. Do not adopt it if you need per-provider cost accounting, if you cannot send post content to a third party, or if you expect a single settings screen to cover every feature. Before committing, open the plugin settings for the one feature you actually want, confirm your chosen provider supports that feature (the feature list is explicit about which ones do), and read the readme.txt requirements against your PHP and WordPress versions.

## FAQ

### Does ClassifAI require a paid API key?

Yes for the cloud providers. The README lists OpenAI, Microsoft Azure AI, Google Gemini, xAI Grok, IBM Watson, Amazon Polly, ElevenLabs and Together AI, all of which are external services with their own accounts and terms. Local options exist for some features through Ollama and a local Stable Diffusion instance.

### Which providers can ClassifAI use for key takeaways?

The feature list names OpenAI's ChatGPT API, Microsoft Azure's OpenAI service and local Ollama. Google Gemini and xAI Grok appear for summaries, titles and text expansion but not for key takeaways.

### Does ClassifAI need ElasticPress?

Only for the smart 404 page and the similar-terms merge. Both are documented as requiring ElasticPress in combination with OpenAI embeddings or Azure OpenAI. The other features do not depend on it.

### What licence is ClassifAI released under?

GPL-2.0. The repository ships a LICENSE.md and package.json declares GPL-2.0-or-later. That covers the plugin code, not the AI provider services it connects to.

## Sources

- [10up/classifai on GitHub](https://github.com/10up/classifai)
- [License: GPL-2.0](https://github.com/10up/classifai/blob/develop/LICENSE)
- [Project website](https://classifaiplugin.com)
- [README](https://github.com/10up/classifai/blob/develop/README.md)
- [Releases](https://github.com/10up/classifai/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/10up-classifai