Open-source project
gorse-io/gorse avatar
gorse-io/gorse

Gorse: An Open Source Recommender Engine That Splits Training From Serving

AI powered open source recommender system engine supports classical/LLM rankers and multimodal content via embedding.

9,925 stars928 forksGoApache-2.0

At a glance

What is it?
Gorse is a Go-based recommender system that handles data import, model training, and online recommendation through a master-worker-server cluster. It supports classical and LLM rankers, multimodal content via embeddings, and ships with a dashboard and RESTful APIs.
Who is it for?
Adopt Gorse if you need a self-hosted recommender that separates offline training from online serving, and you are comfortable running a cluster of Go services with MySQL (MariaDB), MongoDB, or Postgres. Do not adopt it if you expect a single binary to handle both training and prediction at scale, or if you need a turnkey SaaS with managed infrastructure.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • gorse-io/gorse9,925 ★ · +150
Star history
Repository2026-08-022026-11-15
gorse-io/gorse9.8k9.9k

150 Stars in the last 105 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Gorse Actually Solves

Gorse targets teams that want a recommender system without building the plumbing themselves. The README positions it as a universal engine: you import items, users, and interactions, and it trains models to produce recommendations per user. The core problem is the gap between having data and having a working recommendation endpoint. Gorse provides that endpoint via RESTful APIs, and it also offers a GUI dashboard for pipeline editing and monitoring. The intended audience is developers integrating recommendations into online services, not data scientists who want to experiment with algorithms in a notebook. The project is written in Go.

The Master-Worker-Server Architecture

Gorse is not a monolith. The README describes a cluster with three roles. The master node handles model training, non-personalized recommendations, configuration management, and membership management. Worker nodes compute offline recommendations for each user. Server nodes expose the RESTful APIs and handle online real-time recommendations. This separation keeps training on a single master node, with multiple worker nodes and server nodes around it. The architecture is a clear trade-off: it is more complex to operate than a single process, but it allows independent scaling of the serving path. Data storage is pluggable, with MySQL (MariaDB), MongoDB, and Postgres supported. Intermediate results are cached in Redis, MySQL (MariaDB), MongoDB or Postgres. The README does not specify how the master coordinates workers or how state is shared, so you will need to read the official docs for those details.

Getting Started: The Playground and the API

The quick start is a single Docker command. Running `docker run -p 8088:8088 zhenghaoz/gorse-in-one --playground` downloads data from GitRec and imports it into Gorse. The dashboard appears at `http://localhost:8088`. After the item-to-item recommendation task finishes on the Tasks page, you insert feedback. The README shows a JSON array with fields like `FeedbackType`, `UserId`, `ItemId`, `Value`, and `Timestamp`. For example, you can add star feedback for Bob on several LLM repositories. Then `curl http://127.0.0.1:8088/api/recommend/bob?n=10` returns ten recommendations. This flow demonstrates the core loop: import data, train, then query. The playground is a useful way to see the system work before you commit to a full deployment. Note that the README's feedback example includes a Timestamp field.

Multimodal and LLM Support: What the README Claims

The feature list mentions multimodal content via embedding and support for both classical and LLM-based recommenders. The README does not explain how embeddings are generated or which models are used. It also does not show an example of configuring an LLM ranker. This is a gap. The project is clearly moving in that direction, with recent releases in 2026, but the README says little about it. If you need LLM-based ranking, you will have to dig into the official docs or the source code. The multimodal claim is also vague: it says text, images, and videos are supported via embedding, but there is no mention of how you provide those embeddings or whether Gorse computes them internally. Treat these as aspirational features until you verify them in the documentation.

Storage and Caching: A Real Constraint

Gorse supports several databases, but that breadth comes with a caveat. The README says data is stored in MySQL (MariaDB), MongoDB, or Postgres, and intermediate results are cached in Redis, MySQL (MariaDB), MongoDB or Postgres. This means you must run a separate database; Gorse does not embed storage. For a small deployment, that is extra operational overhead. For a large one, you need to decide which database fits your workload. The README does not provide performance benchmarks or guidance on which database to choose. You will need to test with your own data volume. Also, the architecture is described as single-node training, which limits how much data you can train on in one shot. If your interaction data is huge, you may need to partition it yourself or accept longer training times.

Dashboard and RESTful APIs: The Operational Surface

Gorse provides a GUI dashboard on the master node for system monitoring, data import and export, and status checking. The dashboard also allows pipeline editing, which suggests you can tweak the recommendation flow without redeploying. The RESTful APIs cover data CRUD and recommendation requests. The quick start shows a `GET /api/recommend/{user}?n=10` endpoint, which is the core serving interface. The README does not list other endpoints, so you will need to consult the API docs for full coverage. The combination of dashboard and APIs makes Gorse more approachable for operators who are not comfortable with command-line tools. However, it also means the master node becomes a single point of failure for management tasks.

Licensing and Maintenance: What You Are Signing Up For

Gorse is licensed under Apache-2.0, which is permissive and allows commercial use with attribution. That is a positive for adoption. The project is actively maintained, with releases in June, July and October 2026 (latest v0.6.0-alpha.1 on 2026-10-28). The last push is recent, which suggests ongoing development. However, the README does not mention a migration path between versions. Upgrading between releases such as v0.5.10, v0.5.11 and the v0.6.0 alpha may involve schema changes or API modifications, but you will not know until you try. The project is written in Go, so you need Go tooling if you build from source, but the Docker image avoids that. Maintenance cost depends on your willingness to run a multi-node cluster and manage a database. The playground is a good starting point, but production use requires more planning. You should also check the official documentation for upgrade notes, as the README does not provide them.

Alternatives and the Wrong Tool Cases

A common alternative is building a recommendation service with a library like Surprise or LibRec, which Gorse acknowledges as inspirations. Those libraries focus on algorithmic experimentation rather than serving. Gorse differs by providing a complete serving stack with APIs and a dashboard. Another alternative is a commercial SaaS like Amazon Personalize, which handles infrastructure but locks you into a vendor. Gorse is the middle ground: open source, self-hosted, but with more operational burden. The wrong tool case is when you need a simple in-process recommender for a small app. Gorse's cluster architecture is overkill. Also, if you need to train on data that does not fit in a single node, Gorse's single-node training becomes a bottleneck. You would be better off with a distributed training framework or a managed service. Finally, if you cannot run a separate database, Gorse is not for you.

Editorial conclusion

Adopt Gorse if you need a self-hosted recommender that separates offline training from online serving, and you are comfortable running a cluster of Go services with MySQL (MariaDB), MongoDB, or Postgres. Do not adopt it if you expect a single binary to handle both training and prediction at scale, or if you need a turnkey SaaS with managed infrastructure. Before committing, verify that your data volume fits the single-node training constraint, that your database choice is among the supported ones, and that the LLM ranker features match your use case, as the README does not detail their configuration.

Frequently asked questions

What does Gorse do with the data you give it?

You import items, users, and interaction data, and Gorse trains models that generate recommendations for each user, drawing on latest items, user-to-user, item-to-item, and collaborative filtering sources.

How can I try Gorse before building a cluster?

Run docker run -p 8088:8088 zhenghaoz/gorse-in-one --playground, which downloads the GitRec dataset, imports it, and serves the dashboard on port 8088.

Which databases can Gorse store its data in?

MySQL (MariaDB), MongoDB, or Postgres for stored data, with intermediate results cached in Redis, MySQL (MariaDB), MongoDB, and Postgres. The shipped Compose file only starts MySQL.

Does Gorse handle images, video, and LLM rankers?

Yes. Multimodal content such as text, image, and video is supported through embeddings, and the engine supports both classical and LLM rankers.

Is Gorse stable yet, and under what license?

It is distributed under the Apache-2.0 license, and the latest listed releases are v0.6.0-alpha.1, v0.5.11, and v0.5.10, so the version line is still pre-1.0.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/gorse-io-gorse.svg)](https://hysenlabs.com/projects/gorse-io-gorse)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/gorse-io-gorse.svg)](https://hysenlabs.com/projects/gorse-io-gorse)

Was this useful?