Tip: only Ollama models in adapters list

[ColdSpirit0]

Hi, I don't use any API except Ollama so I needed to remove all other adapters and keep only the model list. To achieve this, I created a separate adapter for each Ollama model. I'm not sure this is the best way to do it, but it works for me. My Ollama instance is installed locally, so if you're using a separate server, you'll need to update the URL accordingly.

I also retrieve the context_length for each model and set it as the num_ctx option, allowing the model to use the maximum possible context size instead of just 2048. You can adjust this in the preset if needed.

Configuration

return {
    "olimorris/codecompanion.nvim",
    dependencies = {
        "nvim-lua/plenary.nvim",
        "nvim-treesitter/nvim-treesitter",
    },
    config = function()
        -- reload package, for manual testing
        -- for k, _ in pairs(package.loaded) do if string.match(k, "^codecompanion") then package.loaded[k] = nil end end

        ---@class ModelData
        ---@field num_ctx number

        ---@class AdaptersOpts
        ---@field show_defaults boolean

        ---@class Adapters
        ---@field opts AdaptersOpts

        ---@class Preset
        ---@field model_default string
        ---@field model_data_default ModelData
        ---@field adapters Adapters
        ---@field [string] ModelData
        local preset = {
            -- set your model here (run `ollama ls`)
            model_default = "qwen2.5-coder:7b-instruct",
            -- that data will be used if Ollama doesn't provide it
            model_data_default = { num_ctx = 2048 },
            -- adapter settings for plugin: hide default adapters
            adapters = { opts = { show_defaults = false } },

            -- default ctx size 131072 consumes too much memory
            ["llama3.2:latest"] = { num_ctx = 8192, },
            ["rscr/vikhr_nemo_12b:latest"] = { num_ctx = 8192, },
        }

        local curl = require("plenary.curl")
        local adapters = require("codecompanion.adapters")
        local ollama = adapters.resolve("ollama")

        -- get ollama model names and iterate them
        local model_names = ollama.schema.model.choices(ollama)

        -- request info about model and parse model defaults
        local function request_model_data(model_name)
            local response = curl.post(ollama.env.url .. "/api/show", {
                sync = true,
                headers = { ["content-type"] = "application/json", },
                body = vim.json.encode({ model = model_name }),
            })
            response = vim.json.decode(response.body)

            local data = { num_ctx = preset.model_data_default.num_ctx }
            for i, x in pairs(response.model_info) do
                if string.match(i, "context_length") then
                    data.num_ctx = x
                    break
                end
            end
            return data
        end

        for _, model_name in ipairs(model_names) do
            -- try to get default data from settings
            -- or request it from ollama
            local model_data = preset[model_name]
            if not model_data then
                model_data = request_model_data(model_name)
            end

            -- create a separate adapter for each model with disabled choices list
            preset.adapters[model_name] = function()
                return adapters.extend("ollama", {
                    name = model_name,
                    schema = {
                        model = { default = model_name, choices = false, },
                        num_ctx = { default = model_data.num_ctx },
                    }
                })
            end
        end

        require("codecompanion").setup({
            adapters = preset.adapters,
            strategies = {
                chat = { adapter = preset.model_default, },
                inline = { adapter = preset.model_default, },
            },
        })
    end,
}

[olimorris]

By default, the Ollama adapter only shows models that you have installed, via Ollama:

  schema = {
    ---@type CodeCompanion.Schema
    model = {
      order = 1,
      mapping = "parameters",
      type = "enum",
      desc = "ID of the model to use.",
      default = function(self)
        return get_models(self, { last = true })
      end,
      choices = function(self)
        return get_models(self)
      end,
    },
-- More schema options
}

[ColdSpirit0]

Yes I know that, the reason I did it is that binding ga now opens a menu that lists every Ollama model, without requiring me to enter 'ollama' category. This provides the best UX for me. This also allows me to set custom context size for each model.