Edition No. 1 · 21 Aug 2026
Marketing foundations — measure, multiply, be findable
The first edition. Twelve open-source repositories, each one opened and read rather than taken from a list.
Refreshed on 12 October 2026. The repositories are the ones first published; any that are no longer maintained are left out.
Friday, 21 August 2026. The first edition. Twelve open-source repositories, each one opened and read rather than taken from a list. Eight of the twelve are about reaching an audience and measuring what that reach does. Four are about making a piece of software better. Every number below was read again on the day of this refresh, so the star counts, licences and release dates are current and not the ones from August.
If you only do three things
- Auriti-Labs/geo-optimizer-skill (#8) — five minutes. One command runs it without installing anything for good. It reports whether an AI assistant can read and quote a website at all.
- MinishLab/model2vec (#11) — ten minutes. One install and three lines of Python. It turns sentences into numbers fast enough to do on an ordinary processor.
- umami-software/umami (#1) — two hours. A website statistics tool installed on a machine of your own, which makes every later question about traffic answerable.
Every link in one place
| # | Repository | Project site | Stars | Licence |
|---|---|---|---|---|
| 1 | umami-software/umami | umami.is | 39,311 | MIT |
| 2 | dubinc/dub | dub.co | 24,864 | AGPL-3.0, with one directory under a commercial licence |
| 3 | Huanshere/VideoLingo | docs.videolingo.io | 18,704 | Apache-2.0 |
| 4 | vercel/satori | og-playground.vercel.app | 14,015 | MPL-2.0 |
| 5 | gitroomhq/postiz-app | postiz.com | 36,969 | AGPL-3.0 |
| 6 | n8n-io/n8n | n8n.io | 206,885 | Sustainable Use License, not open source |
| 7 | eliasdabbas/advertools | advertools.readthedocs.io | 1,475 | MIT |
| 8 | Auriti-Labs/geo-optimizer-skill | auriti-labs.github.io/geo-optimizer-skill | 735 | MIT |
| 9 | xyflow/xyflow | xyflow.com | 38,605 | MIT |
| 10 | microsoft/graphrag | microsoft.github.io/graphrag | 36,287 | MIT |
| 11 | MinishLab/model2vec | minish.ai | 2,195 | MIT |
| 12 | stumpy-dev/stumpy | stumpy.readthedocs.io | 4,139 | BSD-3-Clause |
Marketing foundations — measure, multiply, be findable
Twelve repositories, checked and reviewed. Every version verified against the GitHub API and dated.
38.7k stars · MIT · v3.3.1 (2026-08-20) · Track this in Scout · Share this tool
Self-hosted, cookie-free website analytics — the measurement floor for every other marketing move.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You add a small script tag to a site and it records page views. The dashboard shows visitors, page views, where people came from, which campaign links they followed, which pages they left on, and how fast pages loaded. Goals can be defined so a particular action is counted as a conversion. Recent versions add custom dashboards, Core Web Vitals, which are Google's three page-speed measurements, and session replay, which plays back an anonymous recording of one visit. Several people can have accounts, and sites can be grouped. It needs Node.js 18.18 or newer and PostgreSQL 12.14 or newer, and it reuses a database that is already there. What it does not do is match a full analytics suite on deep questions: there is no serious funnel or cohort analysis, and the README names PostgreSQL as the only supported database.
Why it matters
Who it suits. Anyone publishing anything with the intention of being found. Campaign links are the part that pays immediately: they turn "an article was published" into "that article sent nine people, two of whom signed up". It also suits anyone who wants visitor figures without a consent banner, since no cookies are set. Skip it if the questions are about cohorts and multi-step funnels, because a heavier product answers those. And skip it if the site already has a working analytics tool, because two of them is a maintenance job for no new information.
Verdict. Worth two hours, and the first thing on this page to install. It is in excellent health: 39,311 stars, a release on 17 September 2026, code landing on 11 October 2026, and only 42 open issues for a project that size. The session replay in current versions is more useful than it sounds, because watching six real visits through a confusing screen beats any amount of discussion about what to fix. Two honest costs. Upgrades, backups and uptime become somebody's job, which is one more service on a machine that entry #8 now measures. And it is deliberately shallower than the large commercial products, so a question about cohorts will eventually go unanswered. plausible/analytics is the closest alternative and is a heavier install; PostHog/posthog answers the deep questions and costs far more to run.
- Reuses an existing PostgreSQL database, so the install is one container rather than a new service to back up.
- No cookies, so in most places no consent banner is needed and the landing page stays uninterrupted.
- Session replay and page-speed measurements are included, which removes two more tools from a future shopping list.
- Shallower than the large commercial suites on funnels and cohorts: fine for a small site, a limit later.
- Upgrades, backups and uptime are now a local job, on a machine that is probably already busy.
- PostgreSQL is the only database the README supports, so an existing MySQL is of no help.
# Docker, the quickest route git clone https://github.com/umami-software/umami.git cd umami docker compose up -d # Or from source against an existing database pnpm install # .env with DATABASE_URL=postgresql://user:pass@host:5432/umami pnpm run build # creates the tables on first run pnpm run start # serves on localhost:3000
24.7k stars · AGPL-3.0 open-core + commercial EE · no tagged releases; 26,053 commits on main · Track this in Scout · Share this tool
Branded short links with click-to-signup conversion tracking — turns 'did that video work?' into a number.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You point a short domain at it and create links through a dashboard or an interface for programs. Each click is recorded with the country, the device, the browser and the page that sent it. It can carry a click through to a later event, so a sign-up or a payment is attributed to the link that produced it. It supports partner and referral programmes, where someone else promotes a product and is paid for the customers they bring. It also makes link preview images and QR codes. Behind it sit PostgreSQL, Redis and a column store for the click records. What it does not do is give away everything: the main code is under the AGPL-3.0 licence, and one directory in the repository is under a separate commercial licence, so some features belong to the paid hosted service.
Why it matters
Who it suits. Anyone publishing in several places at once who cannot tell which place produces customers. One link per video, per post and per directory listing turns a guess into a count. It suits a marketing team more than a single person, because the partner and referral features assume several people are promoting the same thing. Skip it if a plain redirect is all you need, because simpler tools will do that in minutes. Skip self-hosting in particular if you want the result this week.
Verdict. Worth an hour, using the free hosted version rather than installing it. This is the honest recommendation and it matters: the self-hosted route needs a PostgreSQL database, a Redis cache, a column store and keys from several third-party services, and the project keeps the full instructions on a separate documentation site rather than in the repository. Getting the click data flowing today is worth more than owning the machine. At 24,864 stars it is well used and well documented, and code landed on 4 October 2026. Note that there are no releases on GitHub at all, so there is no version number to pin and the main branch is what you get. If you want something small you can run yourself in an evening, thedevs-network/kutt is the better fit.
- It follows a click through to a sign-up or a sale, rather than stopping at the click.
- A short domain of your own reads as a real organisation rather than a generic shortener.
- Mature and heavily used, with documentation that covers both the hosted and the self-run routes.
- The hardest thing here to install: several services and keys from other companies before anything works.
- The AGPL-3.0 licence on the main code, plus one directory under a commercial licence, so part of it is reserved for the paid service.
- No releases on GitHub, so there is no version to pin and no release notes to read.
git clone https://github.com/dubinc/dub.git cd dub pnpm install pnpm build # then follow the self-hosting guide to fill in the service keys
35.6k stars · AGPL-3.0 · v2.23.0 (2026-08-04) · Track this in Scout · Share this tool
Self-hosted Buffer — schedule one piece of content to 13 platforms including YouTube, X, LinkedIn, Reddit.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You connect accounts on the services it supports, which include X, LinkedIn, Reddit, YouTube, TikTok, Instagram, Threads, Bluesky, Mastodon and more. You then write posts in one editor and place them on a shared calendar, and it publishes each one at the time you chose. It has assistance for drafting and for generating images, and it can be used by several people with different permissions. Behind it sit PostgreSQL, Redis, a workflow service and file storage. There is a paid hosted version from the same company. What it does not do is get you permission: each social service has its own approval process for programs that post on a user's behalf, and the repository does not shorten that. The README gives no install commands and sends you to a separate quick-start guide.
Why it matters
Who it suits. Anyone publishing regularly to three or more services who currently does it by hand. The benefit is consistency rather than cleverness: queueing a month of posts in one sitting is worth more than any individual trick. It suits a small team, because several people can share one calendar. Skip it if you post to one service, because that service's own scheduler is free and already there. Skip it too if the machine available is small, because this is a heavy set of services to keep running.
Verdict. Worth an evening if cross-posting has already become the thing that gets skipped. At 36,969 stars it is the best-known free scheduler of its kind, version 2.25.1 was released on 11 October 2026, and code landed on 9 October 2026, so it is actively developed and a company stands behind it. Three things to weigh before installing. The real work is not the software: approval from X and TikTok in particular is slow and sometimes refused, and until it arrives those parts of the calendar do nothing. The AGPL-3.0 licence brings obligations if you ever expose a modified copy to other people, so read it if you plan to change the code. And check the memory on the machine first, because PostgreSQL, Redis, a workflow service and the application itself add up. The smaller alternative is inovector/mixpost, which is MIT licensed and lighter.
- The widest coverage of social services of any scheduler you can install yourself.
- Actively developed with a company behind it, and a release the day before this refresh.
- Running it yourself means adding another service costs no extra subscription.
- A heavy stack: PostgreSQL, Redis, a workflow service, storage and background workers.
- Getting posting permission from each social service is slow, tedious, and sometimes refused.
- The AGPL-3.0 licence brings obligations if a modified copy is ever made available to others.
git clone https://github.com/gitroomhq/postiz-app.git cd postiz-app cp .env.example .env # fill in the database, cache, storage and service keys, then docker compose up -d
203.7k stars · Sustainable Use License · n8n@2.37.11 (2026-09-07) · Track this in Scout · Share this tool
Visual workflow automation — the hub that wires every other tool on this list into one pipeline.
▶Repo detailsthe review · specs · pros & cons · install
What it does
A workflow is built by placing nodes on a canvas: a trigger that starts it, then steps that fetch, transform and send information. More than 400 services are supported, and any service with a web interface can be reached with a generic request node. Steps can include JavaScript or Python when dragging boxes is not enough. It has built-in steps for talking to language models, and it can act as a server or client for the Model Context Protocol, which is a standard way for assistants to use external tools. It runs on a schedule, on a web request, or on an event from a connected service. What it does not do is come under an open-source licence: the main code is under the Sustainable Use License, which permits internal business use and forbids reselling it as a service, with separate enterprise terms for some features.
Why it matters
Who it suits. Anyone whose work involves the same five-step shuffle every week between services that do not talk to each other. The visual canvas is the real benefit: a chain you can see is a chain you can debug without being a programmer. It also suits a team that wants fixed costs, because self-hosting means volume does not change the bill. Skip it if you want to resell the automation as a product, because the licence forbids that. Skip it too if one scheduled script would do, because this is a service to keep running.
Verdict. Worth an evening, and it is the piece that makes the other tools in this edition into one chain rather than eight separate things. At 206,885 stars it is by a wide margin the largest repository in this edition, release 2.42.6 landed on 9 October 2026 and code on 8 October 2026. Three things to be clear about. The licence is not open source, and the distinction is practical rather than academic: internal use is fine, selling a hosted copy is not. It is resource-hungry, so a busy instance competes for memory with everything else on the same machine. And workflows that call a language model on every item can quietly run up a bill at the model provider, so put a limit on the loop before you leave it running. If the licence is the problem, activepieces/activepieces is MIT licensed for its community edition.
- Visual, so a workflow is buildable and, more to the point, fixable without being a programmer.
- More than 400 connections, plus a generic request step for anything not on the list.
- Fixed cost on a machine of your own regardless of how many times a workflow runs.
- Not open source. The Sustainable Use License forbids offering it as a competing service.
- Resource-hungry, and a busy instance competes for memory with everything else on the machine.
- Easy to start and fiddly to debug once workflows get long, and a step that calls a language model on every item can run up a real bill.
# The install script curl -fsSL https://get.n8n.io | sh # Or manually docker volume create n8n_data docker run -it --rm --name n8n -p 5678:5678 \ -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n
18.4k stars · Apache-2.0 · v3.0.1 (2026-02-28) · Track this in Scout · Share this tool
One-click transcribe, translate and dub pipeline; doubles every video into a Russian edition.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You give it a video file or a link. It transcribes the speech using Whisper, which is a speech recognition model, with word-level timing. It then splits the subtitles at natural sentence breaks rather than at fixed character counts. Translation runs in three passes: translate, criticise the translation, then adapt it to fit the time available on screen. It keeps a list of terms so names and product words stay the same throughout. Finally it can generate dubbed audio, using a cloud voice service or a voice cloned from a sample, and align that audio to the original timing. It writes subtitle files you can use anywhere. What it does not do is produce broadcast-ready dubbing: the generated speech varies slightly in length, so a recording with tight on-screen timing still needs a person to check it.
Why it matters
Who it suits. Anyone publishing video who wants a second language edition without filming twice. Subtitle files are useful on their own as well: they become chapter markers and written text for a web page. It suits someone comfortable installing Python programs. Skip it if you have neither a graphics card nor a budget for cloud transcription, because the slow path is very slow. Skip it too if the material is legally sensitive, because a machine translation of a contract is not a translation of a contract.
Verdict. Worth an afternoon, and it is the most capable thing of its kind that is free. The criticise-and-adapt pass is what separates it from a plain machine translation, and the difference is visible in the first minute of output. The install is much better than it was: the project now recommends a tool called uv that downloads Python 3.10 and builds the environment on its own, and it says the older conda route will not be maintained. Version 3.1.1 landed on 27 September 2026 and code on 30 September 2026, so it is actively worked on. Two honest warnings. Running Whisper locally wants a graphics card, and the Docker image requires CUDA 12.4 and a recent NVIDIA driver, so on a plain processor you are pushed towards paid cloud transcription. And the dubbing step costs money at a voice service unless you use the free local option, which sounds noticeably worse.
- It covers the whole chain in one program, rather than one step of it.
- The criticise-and-adapt translation pass produces noticeably better subtitles than raw machine translation.
- It speaks to several voice services, so it fits an account that already exists, and Apache-2.0 is a plain licence.
- Local speech recognition really wants a graphics card; the Docker route demands CUDA 12.4 and a driver above 550.
- Dubbed audio drifts in length, so a recording with precise on-screen timing needs a manual pass.
- A Python install with many dependencies and a web interface, which is more to go wrong than a single command.
# FFmpeg first sudo apt install ffmpeg # or: brew install ffmpeg # The recommended route git clone https://github.com/Huanshere/VideoLingo.git cd VideoLingo python setup_env.py .venv/bin/streamlit run st.py
13.9k stars · MPL-2.0 · 0.33.4 (2026-08-24) · Track this in Scout · Share this tool
Turns HTML/CSS into images — mass-produce thumbnail variants and blog OG images from one template.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You call it from JavaScript with an element and a size, and it returns the image as SVG text. SVG is an image format made of shapes and text rather than pixels, so it stays sharp at any size. You pass it the font files you want, which is how non-Latin alphabets are handled. It renders in milliseconds and needs no browser and no graphics card. It is the engine behind the automatic preview images on Vercel's own service. What it does not do is produce PNG files directly, and it does not support all of CSS: only a subset is implemented, so complicated grid layouts and visual filters behave differently or not at all. For a PNG you pass its output to a second library.
Why it matters
Who it suits. Anyone who needs many versions of the same image: video thumbnails with different headlines, preview images for every article, the same picture in two alphabets. It suits a team that already writes JavaScript, because this is a building block and not an application. Skip it if you need one image, because design software will be faster. Skip it too if the design depends on CSS features outside its subset, because finding out which ones are missing takes longer than drawing the thing.
Verdict. Worth an hour if images are a repeated chore, and nothing at all if they are not. The honest limit is in the name of the thing: it is a rendering primitive, so you write a small wrapper around it before it does anything useful. Once that wrapper exists, a new variation costs one line. The npm package is at version 0.47.1 and code landed on 2 October 2026, so it is current, and MPL-2.0 is a real open-source licence with no paid tier carved out. Two notes. Non-Latin alphabets render correctly, but only if you supply a font file that contains those letters, which is easy to forget. And it does nothing about testing which image works better: that still happens wherever the images are published.
- Many variations of one image cost one line each, including versions in different alphabets.
- No subscription, no graphics card and no browser: it is a library that runs in milliseconds.
- The same template can produce both video thumbnails and web page preview images, so one design covers both.
- It is a building block, not an application, so you write a wrapper before it is useful.
- Only part of CSS is implemented, and complex layouts and filters differ quietly from a browser.
- It returns SVG only, so a PNG needs a second library in the chain.
The same template then produces the OG images for your blog posts, so the site and the channel finally look like one brand instead of two.
npm install satori
1.4k stars · MIT · v0.18.0 on PyPI (2026-06-17) · Track this in Scout · Share this tool
Python toolkit built by a working SEO practitioner — crawling, sitemaps, SERP analysis, keyword generation.
▶Repo detailsthe review · specs · pros & cons · install
What it does
Its crawler walks a site and returns every page with its title, description, headings and links, so missing titles and duplicates show up as rows in a table. It reads a site map and returns the list of pages a site publishes, with dates, which shows what a competitor writes about and how often. It builds keyword combinations from a short list of words, in any language. It also parses the file that tells crawlers where they may go, and analyses text for word frequency. The latest release is 0.18.0, published on 17 June 2026, and the code was last changed at the end of that month. It is MIT licensed and pure Python. What it does not do is tell anyone how many people search for a word; there are no search-volume figures of its own anywhere in it.
Why it matters
Who it suits. Anyone holding a pile of competitor text and no way to count it. It suits Python projects especially, because it needs no new language, no server and no dashboard. Entries 4 and 5 in this edition both end in a pile of text, which is why this one is raised a second time: it was first published in Edition 1 on 21 August 2026 and is the only tool in the whole ledger that reads such a pile. Skip it if a hosted marketing dashboard is already paid for and used.
Verdict. Worth an afternoon, and the only entry here raised twice. Three things to know. It gives no search-volume data, so pair it with a free search console or a paid source for demand figures. Its output is tables, which need somewhere to be looked at, and that is a large part of why entry 12 is on this page. And its crawler is eager, so set a page limit and a delay before pointing it at anybody's site. The release pace is slow and steady rather than fast: one release in June 2026, after many years of the same.
- MIT, pure Python, and it drops into an existing project with no new language and no new service.
- Written by a working search-marketing specialist, so the functions are named after real tasks.
- Years of steady, unhurried releases rather than a burst of activity.
- No search-volume figures of its own, so demand has to come from somewhere else.
- Output is tables, which need a separate place to be read.
- The crawler is eager; without a page limit and a delay it will annoy a site owner.
source venv/bin/activate pip install advertools
776 stars · MIT · v4.17.1 (2026-08-31) · Track this in Scout · Share this tool
Audits whether ChatGPT, Perplexity and Google AI Overviews can find and cite your site — CLI, Python library, MCP server and Astro integration.
▶Repo detailsthe review · specs · pros & cons · install
What it does
It fetches a site and checks the signals an AI assistant uses to read and cite it. Those include robots.txt, which tells crawlers what they may read, llms.txt, which is a plain summary file written for language models, JSON-LD schema, which is structured data describing the page, plus page metadata and heading structure. It produces a score from 0 to 100 across eight scored categories. It can also generate the fixes, including robots.txt rules, an llms.txt file and schema blocks. It runs as a command-line tool, a Python library, an MCP server, a GitHub Action and an Astro integration, so it can run on every build. Version 4.19.0 was published on 9 October 2026. It does not get a site mentioned by an assistant: it only removes the mechanical reasons it would not be.
Why it matters
Who it suits. People publishing documentation or a content site who have noticed that assistants answer questions in their subject without naming them. It also suits a team already running checks on every build, because this slots in beside them. Skip it if the site is not published yet, since there is nothing to score.
Verdict. Worth an afternoon, and genuinely worth wiring into a build so the score does not quietly rot. Two warnings. It grades machine readability, which is a proxy; a perfect score on a site nobody links to still gets cited by nobody. And the project moves fast, with four point releases since the summer, so pin the version you audit against. llms-txt is the specification behind its most common finding. elmo is the self-hosted way to track mentions over time rather than audit a site once.
- It turns a vague goal into a checklist, with eight scored categories rather than opinions.
- The MCP server lets a coding assistant run the audit and apply the fixes in one session.
- Clearly alive: 1.0k stars and version 4.19.0 published on 9 October 2026.
- The score measures machine readability, not reputation. Links and authority still decide citations.
- The maintainers also sell a hosted monitoring product, so read the "track this continuously" advice with that in mind.
- Four major versions in a year. Expect the output to change between upgrades.
Running it as an Astro integration means the score gets checked on every build instead of once, in an afternoon, and then forgotten.
# no install needed uvx --from geo-optimizer-skill geo audit --url https://example.com # or install it, Python 3.9 or newer pip install -U geo-optimizer-skill geo audit --url https://example.com
38.3k stars · MIT · @xyflow/react v12.11.3 (2026-08-12) · Track this in Scout · Share this tool
React Flow — node-and-edge canvas with pan, zoom, minimap; the most direct way to render Grasppy's subtopic map.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You give it nodes and edges as plain data. It renders the diagram and provides panning, zooming, a small overview map, selection, multi-select and drag-and-drop out of the box. Each node is a component you write, so a node can be a card with text, an image, a form or a chart. Edges can be styled, labelled and made interactive. It handles the awkward parts that are easy to underestimate: keeping the view steady while nodes move, hit detection, and keeping large diagrams responsive. There are two packages, one for React and one for Svelte. What it does not do is decide where things go: there is no layout algorithm included, so you add a separate library such as dagre or elkjs and tune it yourself. Some extra components sit behind a paid subscription from the same team.
Why it matters
Who it suits. Anyone building something where a diagram is the interface rather than an illustration: a workflow editor, a dependency map, a topic map over a long document. It suits a React or Svelte project especially, because the nodes reuse components that already exist. Skip it if the diagram is static, because an image will be lighter and simpler. Skip it too if you need thousands of boxes visible at once, because this draws with web page elements rather than a canvas.
Verdict. Worth two hours, and it is the shortest route from a list of topics to something a person can actually explore. The reason to pick it over the alternatives is the node model: because each node is a normal component, the diagram inherits the look of the rest of the application instead of needing a second visual language. At 38,605 stars it is very widely used, the React package is at version 12.12.0, and code landed on 7 October 2026. Three limits. Performance starts to suffer somewhere above one or two thousand visible nodes, and the fix is to show fewer rather than to tune it. Layout is your problem, and tuning a layout library takes longer than most people budget. And some polish features are in the paid tier, so check the free package covers what the design assumes.
- Nodes are ordinary components, so a diagram reuses the interface a project already has.
- Panning, zooming, overview map, selection and dragging all arrive working, which is the expensive part to write.
- MIT licence, very widely used, with documentation thorough enough to answer most questions without asking.
- No layout algorithm included: you add dagre or elkjs and tune the result yourself.
- It draws with web page elements, so performance falls away past roughly one or two thousand visible nodes.
- Some extra components are behind a paid subscription from the same team.
FastAPI returns {nodes, edges} from your topic pipeline; the React app feeds it into <ReactFlow> and calls a detail endpoint on node click.
# React npm install @xyflow/react # Svelte npm install @xyflow/svelte
35.9k stars · MIT · v3.1.2 (2026-08-21) · Track this in Scout · Share this tool
Builds a knowledge graph from text, clusters it into nested communities, writes a summary for each level.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You put text files in a folder and run it. It uses a language model to extract entities and the relationships between them, assembles those into a graph, then clusters the graph into communities and clusters those communities again, producing a hierarchy. For each community at each level it writes a readable summary. Queries then run in one of two ways: a local search that answers from specific entities, or a global search that answers from the top-level summaries and so can address a question about the whole collection. It writes its results as data files you can read directly. What it does not do is come cheap: indexing one long document can mean thousands of calls to a language model, so every import has a real and measurable cost.
Why it matters
Who it suits. Anyone who needs an answer about a whole collection rather than a passage inside it. The question "summarise this entire thread" is the one plain keyword search cannot answer at all, and the global search mode is built for exactly that. It also suits anyone designing a system of this kind, because the cluster-and-summarise step is the clearest published reference for the idea. Skip it for short inputs, because the cost per document does not shrink. Skip it too if operations are not your strength, because this is config files, long-running jobs and data artifacts.
Verdict. Worth studying even if you never run it in production, and the reason is the design rather than the code. The hierarchy of clusters, each with a generated title and summary, is a product specification written out by a research team and given away under a plain MIT licence. At 36,287 stars it is well known, version 3.3.0 landed on 8 October 2026 and code the same day, so it is actively maintained. Three warnings, and they are the real content of this entry. The cost is the headline: indexing is thousands of model calls, and that is money per import, so measure it on one document before pointing it at a thousand. It is operationally the heaviest thing here. And the project warns to run graphrag init --root [path] --force between minor version changes, which tells you the configuration format moves. For something lighter with the same shape, HKUDS/LightRAG is the obvious comparison.
- It produces both the hierarchy and the human-readable summaries in one run.
- The global query mode answers questions about a whole collection, which plain search cannot do at all.
- Plain MIT licence from a research team at a large company, with a release on 8 October 2026.
- Expensive: indexing one long document can mean thousands of language model calls, so every import costs money.
- Operationally the heaviest thing in this edition: configuration files, data artifacts and long-running jobs.
- The configuration format changes between minor versions, and the project tells you to reinitialise when it does.
python3 -m venv venv source venv/bin/activate python -m pip install graphrag graphrag init # writes the settings files # put text files in the input folder and add your provider key graphrag index # builds the graph and the summaries graphrag query "What are the main themes in these documents?"
2.2k stars · MIT · v0.9.0 (2026-08-12) · Track this in Scout · Share this tool
Distills sentence-transformers into static embeddings ~15x smaller and hundreds of times faster on plain CPU.
▶Repo detailsthe review · specs · pros & cons · install
What it does
It takes a sentence-transformer model, which is a neural network that turns text into numbers, and distils it into a static model: one fixed vector per token, with no network to run at query time. You can use the pretrained models the project publishes or distil your own. The result loads in a few lines and replaces the original model in the places that expect one, including topic modelling libraries and vector search. It supports several languages and ships models of different sizes. What it does not do is match the original for accuracy: static vectors lose context, so nuance, negation and word order are handled worse than by the network they came from.
Why it matters
Who it suits. Anyone doing clustering, search by meaning or topic modelling on a machine with no graphics card, where the embedding step is what makes the whole idea feel too expensive. It also suits anything that has to embed text while a person waits, because a lookup is fast enough to do in a request. Skip it where accuracy decides the outcome, such as ranking legal or medical results, because the loss is real. Test it on your own language before committing, because the gap varies by language.
Verdict. Worth ten minutes, and the most useful small project in this edition. The reason is narrow and practical: it removes the step that makes a whole class of features look unaffordable, and it does so without a graphics card or a model provider. pip install model2vec and three lines of Python is the entire trial, so there is nothing to commit to. At 2,195 stars it is small, version 0.10.0 landed on 11 October 2026 and code on 5 September 2026, so it is active. Three honest limits. Static vectors are less accurate than the network they were distilled from, especially on short strings and on negation. The quality depends heavily on which distilled model you choose, and the published models differ. And the team behind it is small, which matters more here than usual because the pretrained models are part of the product.
- No graphics card and no neural network at query time, so it runs comfortably on an ordinary processor.
- A direct replacement for sentence-transformers in topic modelling and vector search, so existing code barely changes.
- Plain MIT licence, actively released, with pretrained models published and ready to download.
- Static vectors lose accuracy against the network they came from, particularly on nuance and negation.
- Weaker on very short strings and on some languages, so test before committing to it.
- A small team, and the quality depends on which published model you pick.
You can embed a full transcript in seconds and keep clustering affordable, which quietly makes several features on your roadmap possible instead of theoretical.
python3 -m venv venv source venv/bin/activate pip install model2vec
4.2k stars · BSD-3-Clause · v1.14.1 (2026-02-08) · Track this in Scout · Share this tool
Matrix profile — finds every repeating shape and every anomaly in a long time series without being told what to look for.
▶Repo detailsthe review · specs · pros & cons · install
What it does
You pass it an array of numbers and a window length. It computes the matrix profile, which for every window in the series records how far it is from its nearest match elsewhere. Low values mark repeated shapes, called motifs; high values mark unusual stretches, called discords. From that one computation you get both. It scales to millions of points using Numba, which compiles Python to machine code, and can spread the work across processor cores, several machines with Dask, or a graphics card. There is also a match function that detects a known shape in new data as it arrives, and support for multiple series at once. What it does not do is tell you anything about the future: it reports which shapes recur, and most recurring shapes carry no predictive value, so filtering is on you.
Why it matters
Who it suits. Anyone with a long series of measurements and a suspicion that something in it repeats: price data, sensor readings, server metrics, demand figures. The appeal is that it needs no labels, no training and no machine-learning background. It suits anyone who would otherwise be guessing at indicator combinations. Skip it if the series is short, because the method needs length to find repetition. Skip it too if you expect strategies rather than candidates, because what comes out is a list of shapes and nothing more.
Verdict. Worth an afternoon if you have the data, with expectations set correctly. The honest framing is that it inverts the usual approach: instead of proposing a pattern and testing it, you ask the data which patterns exist and then test those. That is a better use of time, and it is still only the first half of the work. At 4,139 stars it is well established with a real maintainer team, the licence is BSD-3-Clause, which places no restriction on shipping it inside a commercial product, and version 1.14.1 was released on 8 February 2026 with code on 31 July 2026. A release that old would be worrying on its own, and it is not: the code date is the one that counts, and seven months between releases is normal for a mature library. Two limits. Memory and processor use scale with the length of the series, so three years of minute-by-minute data is roughly a million points and will need chunking. And choosing the window length is a judgement that changes every result downstream, so expect to try several.
- Finds repeated shapes with no labels, no training and no machine-learning background needed.
- BSD-3-Clause licence, so there is no restriction on including it in a commercial product.
- Well documented with a real maintainer team, and it scales from one processor to many machines or a graphics card.
- Memory and processor use grow with the length of the series, so long histories need chunking.
- Raw repeated shapes are not strategies: most carry no predictive value, so heavy filtering follows.
- Choosing the window length is a judgement call that changes everything after it.
Pair with kernc/backtesting.py to test each surviving motif.
python3 -m venv venv source venv/bin/activate python -m pip install stumpy # or: conda install -c conda-forge stumpy
Checked, and left out
Nothing to show for this edition. Recording the repositories that were checked and rejected began with Edition No. 4, and every edition from there on has the list.
Know a repository we should check?