[Neovim] Teaming up codeCompanion with a remote Open WebUI instance

If you are using Neovim, you have likely come across the plugin Code Companion. This plugin allows you to integrate Large Language Models (LLMs) into Neovim, much like you would expect from any modern IDE.

While Code Companion offers a plethora of features, this blog post will focus on a specific use case: configuring the plugin to work with a self-hosted instance of Open WebUI. Open WebUI is a popular, open-source web interface for interacting with LLMs, and integrating it with Neovim can provide a seamless and powerful coding experience.

This blog post assumes you are using LazyVim. If you’re not, please refer to the official Code Companion documentation for alternative installation methods.

installation

To install the plugin with LazyVim, add the following code to your configuration:

return {
  "olimorris/codecompanion.nvim",
  version = "^19.0.0",
  opts = {},
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
  },
},

Congratulations! You have now installed the plugin. You can now proceed to configure it to use your remote WebUI instance.

configuration

Configuring Code Companion to work with Open WebUI involves three main steps:

1. Obtaining your API key from Open WebUI
2. Creating a new adapter in the plugin to connect to your instance
3. Configuring the interaction mode

Getting the API key

First:

• connect to your Open WebUI instance
• click on your initial at the top-right corner of the screen and open the Settings menu
• open the Account section

There you can create and copy you API key. Copy the value of the key (it should start with sk-...).

Creating the new adapter

Unfortunately, there is no out-of-the-box adapter to connect to a WebUI instance. You will need to write a custom one.

In codecompanion.nvim, an adapter is an abstraction layer that translates the plugin’s generic instructions into the specific API format required by a particular Large Language Model (LLM) provider. In simpler terms, this is what connects you to your AI provider.

Since Open WebUI follows the OpenAI API specification, you will need to create a new adapter called openwebui that extends the openai_compatible adapter from Code Companion. You will then need to provide your API key and the URL of your Open WebUI instance. This new definition needs to be done in the opts table.

The adapters definition is shown below.

adapters = {
            http = {
                openwebui = function()
                    return require("codecompanion.adapters").extend("openai_compatible", {
                        env = {
                            url = "OPEN_WEBUI_URL",
                            api_key = "OPEN_WEBUI_API",
                        }
                    })
                end,
            },
        }

As you can see, the URL and the API key are not hardcoded into the configuration file directly. They are stored in two environment variables which will be automatically read by the plugin.

Interaction mode

You can now use this adapter to set up your interaction with Code Companion.

If you want to know more about what are interaction, refer to the official documentation

When you define an interaction, the two main things you need to specify are:

1. the adapter to use
2. which model you want to use

Add the following code in the opts table after the adapters definition. Feel free to use whichever model you want to.

 interactions = {
            chat = {
                adapter = "openwebui",
                model = "qwen3-coder:30b",
            },
            inline = {
                adapter = "openwebui",
                model = "qwen3-coder:30b",
            }
        }

Conclusion

The complete configuration file looks like the one below:

return {
    "olimorris/codecompanion.nvim",
    version = "^19.0.0",
    keys = {
        { "<leader>cc", "<cmd>CodeCompanionChat<cr>", desc = "CodeCompanion Chat"},
        { "<leader>ca", "<cmd>CodeCompanionAction<cr>", desc = "CodeCompanion Action"}
    },
    opts = {
        adapters = {
            http = {
                openwebui = function()
                    return require("codecompanion.adapters").extend("openai_compatible", {
                        env = {
                            url = "OPEN_WEBUI_URL",
                            api_key = "OPEN_WEBUI_API",
                        }
                    })
                end,
            },
        },
        interactions = {
            chat = {
                adapter = "openwebui",
                model = "qwen3-coder:30b",
            },
            inline = {
                adapter = "openwebui",
                model = "qwen3-coder:30b",
            }
        }
    },
    dependencies = {
        "nvim-lua/plenary.nvim",
        "nvim-treesitter/nvim-treesitter",
    },
}

Congratulation you have now setup codecompanion to use your self hosted Open WebUI instance. Take a look at the official documentation as there is a lot of other tweak possible

This blog post is licensed under CC BY-SA 4.0