minuet-ai.nvim has five completion frontends and one Neovim version floor that covers four of them

Five frontends behind one stated version floor

The completion source can present itself five ways: virtual text, nvim-cmp, blink-cmp, the built-in completion frontend, and mini.completion. Two of those are optional plugins you may not have, and the lazy.nvim snippet says so in its own comments, noting that if you use the virtual-text frontend then nvim-cmp is not required, and likewise for blink. The version floor is where the list stops agreeing with itself. Requirements say Neovim 0.10 and newer, while the built-in frontend is annotated as requiring 0.11 or newer. So the stated floor is correct for four frontends and wrong for the fifth, and nothing on the page tells you which one you are on until you pick it. The requirements list has one more loose end: plenary.nvim is still shown, struck through, next to a note that the plugin now uses the builtin `vim.system` instead.

specs = {
    {
        'milanglacier/minuet-ai.nvim',
        config = function()
            require('minuet').setup {
                -- Your configuration options here
            }
        end,
    }
}

Two completion modes, chosen by what the model can do

The request shape depends on the model behind the provider. One mode is built around specialized prompts and enhancements aimed at chat-based models, where the model is completing a conversation rather than a masked span. The other is fill-in-the-middle, described as available for compatible models and named examples being DeepSeek, Codestral, Qwen and others. The provider list in the table of contents is where the distinction becomes structural: there is an OpenAI entry, a Claude entry, a Gemini entry, an OpenAI-compatible entry and an OpenAI-FIM-compatible entry, and the last of those has its own sub-entry for APIs that are not OpenAI-FIM-compatible. Fill-in-the-middle only helps if the model was trained with those sentinel tokens in place, so a provider that merely speaks an OpenAI-shaped HTTP protocol is not automatically a provider that can do this. The plugin also states that it runs no proprietary binary in the background and needs nothing beyond curl and a provider you already have credentials for, so the only moving part you add is the plugin itself.

Typed text re-anchors a suggestion instead of throwing it away

Three behaviours here are about not wasting requests. Streaming exists so a completion can be delivered even when the model is slow. Multi-line suggestions can be accepted line by line, which lets a long suggestion be pulled in incrementally at whatever pace you are working. The third is the interesting one: when what you have typed matches the beginning of a suggestion already on screen, the completion is kept in sync with your text rather than discarded, and the stated reason is to reduce unnecessary requests to the model. That turns each keystroke inside a suggestion into a re-anchoring operation instead of a fresh call, so the cost of typing through a long completion stays flat. It also means the displayed text and the pending suggestion are no longer independent, which is the trade the feature makes.

Three setup snippets, all of them cut off partway

The quick start on this page offers one snippet per frontend, and none of the three is complete. The virtual-text block lists a keymap with accept, accept one line, accept a prompted number of lines, and previous and next, including the example that pressing the accept-n-lines key followed by 2 and enter takes two lines, and then stops partway through the next entry, at the letters dis. The nvim-cmp block is cut off after a comment that begins by saying the following configuration binds something. The blink-cmp block ends at the opening of its keymap table. The page's own table of contents promises a separate section for each of these, so the intent is clear and the visible text simply stops there. That matters if you are following the page literally, since a truncated Lua table is a syntax error rather than a partial example. Two of the five frontends need no setup section at all on the visible page: the built-in frontend is annotated with its version requirement in the feature list, and mini.completion is named only in the list of supported frontends.

A 2000 millisecond default and an entry named after a delay complaint

The comparison-plugin snippet sets a fetch timeout and explains itself in comments:

require('cmp').setup {
    sources = {
        {
             -- Include minuet as a source to enable autocompletion
            { name = 'minuet' },
            -- and your other sources
        }
    },
    performance = {
        -- It is recommended to increase the timeout duration due to
        -- the typically slower response speed of LLMs compared to
        -- other completion sources. This is not needed when you only
        -- need manual completion.
        fetching_timeout = 2000,
    },
}

So the default is two seconds, the recommendation is to raise it, and the case where it does not matter is manual-only completion. The same page's table of contents carries a troubleshooting entry titled around a significant input delay when moving to a new line with nvim-cmp, which is the symptom you would expect from a remote source competing with a local one. The text of that entry is past the visible end of the page, so the symptom is named and the remedy is not shown here.

The type check asks Neovim where its own runtime is

The make file carries an unusual bootstrap. The runtime directory is not a constant; it is produced by running a headless Neovim, asking it to print an environment variable, falling back to deriving the path from the location of the Neovim binary itself, and discarding errors from the attempt. That value is then handed to a language server invocation that checks the whole tree at warning level, so warnings fail the build. Tests run inside headless Neovim with no user configuration, no viminfo and no swapfile, which is the right way to keep a developer's own config out of the results, and the test target depends on the type check, so running the suite requires a language server binary that Neovim does not ship. Two targets sit outside that chain: a benchmark that runs a duet edits benchmark script, and format checks that cover the lua and tests directories only.

Prompts and recipes are documents at the repository root

The tree explains more about how this plugin is maintained than the feature list does. Beside the plugin source and its tests sit two markdown files, one named for prompts and one named for recipes, plus a changelog, an editor config, a Lua language server config, a formatter config, and two agent instruction files at the root. Keeping prompts as documents rather than as strings buried in source means the text sent to a model can be reviewed on its own, and a recipes file of that name lines up with the command list in the table of contents, which includes changing provider, changing model, changing preset, and one command per frontend, along with a command that starts the in-process language server mode. The experimental feature sits alongside all this: next edit prediction is reached through the duet commands, is called highly experimental in the feature list, has a section in the table of contents with an entry titled TODO, and is the one feature with a benchmark target behind it.

Editorial conclusion

minuet-ai.nvim fits a Neovim user on 0.10 or newer who has an API key for one supported provider and wants completions that can be walked through line by line rather than accepted wholesale. It does not fit someone on Neovim below 0.10, someone who needs a documented next edit prediction, or a team that wants a completion backend with no network dependency at all. Verify four things before adopting it: which frontend you will actually use, since one of the five needs a newer Neovim than the stated floor and two of the others are optional plugins you may not have, which completion mode your chosen model supports, since a chat model and a fill-in-the-middle model take different request paths, that the timeout you set in your comparison plugin is large enough for a remote model, and that the type check step can run on your machine, since the suite depends on a language server binary that Neovim does not ship.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. milanglacier/minuet-ai.nvim on GitHub
4. README
5. Releases