Venice.ai

[plague-doctor]

Venice.ai is a private AI platform that provides uncensored and unrestricted access to AI models. It allows users to interact with AI models in a private and secure environment, with all user data stored locally in the browser and never on Venice servers. Venice.ai also offers a range of features, including document uploads, image generation, and a utility token called Venice Token (VVV) that can be staked to access the Venice API.

Configuration of the adapter:

  require("codecompanion").setup({
    adapters = {
      http = {
        venice = function()
          return require("codecompanion.adapters").extend("openai_compatible", {
            name = "venice",
            formatted_name = "Venice",
            roles = {
              llm = "assistant",
              user = "user",
            },
            opts = {
              stream = true,
            },
            features = {
              text = true,
              tokens = true,
              vision = false,
            },
            env = {
              url = "https://api.venice.ai/api",
              chat_url = "/v1/chat/completions",
              -- api_key = "",  <-- get from sys env: OPENAI_API_KEY
            },
            schema = {
              model = {
                default = "deepseek-coder-v2-lite",
                -- Other models available:
                -- venice-uncensored
                -- qwen-2.5-qwq-32b
                -- qwen3-4b
                -- mistral-31-24b
                -- qwen3-235b
                -- llama-3.2-3b
                -- llama-3.3-70b
                -- llama-3.1-405b
                -- dolphin-2.9.2-qwen2-72b
                -- qwen-2.5-vl
                -- qwen-2.5-coder-32b
                -- deepseek-r1-671b
                -- deepseek-coder-v2-lite
              },
              temperature = {
                order = 2,
                mapping = "parameters",
                type = "number",
                optional = true,
                default = 0.8,
                desc = "What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or top_p but not both.",
                validate = function(n)
                  return n >= 0 and n <= 2, "Must be between 0 and 2"
                end,
              },
              max_completion_tokens = {
                order = 3,
                mapping = "parameters",
                type = "integer",
                optional = true,
                default = nil,
                desc = "An upper bound for the number of tokens that can be generated for a completion.",
                validate = function(n)
                  return n > 0, "Must be greater than 0"
                end,
              },
              presence_penalty = {
                order = 4,
                mapping = "parameters",
                type = "number",
                optional = true,
                default = 0,
                desc = "Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.",
                validate = function(n)
                  return n >= -2 and n <= 2, "Must be between -2 and 2"
                end,
              },
              top_p = {
                order = 5,
                mapping = "parameters",
                type = "number",
                optional = true,
                default = 0.9,
                desc = "A higher value (e.g., 0.95) will lead to more diverse text, while a lower value (e.g., 0.5) will generate more focused and conservative text. (Default: 0.9)",
                validate = function(n)
                  return n >= 0 and n <= 1, "Must be between 0 and 1"
                end,
              },
              stop = {
                order = 6,
                mapping = "parameters",
                type = "string",
                optional = true,
                default = nil,
                desc = "Sets the stop sequences to use. When this pattern is encountered the LLM will stop generating text and return. Multiple stop patterns may be set by specifying multiple separate stop parameters in a modelfile.",
                validate = function(s)
                  return s:len() > 0, "Cannot be an empty string"
                end,
              },
              frequency_penalty = {
                order = 8,
                mapping = "parameters",
                type = "number",
                optional = true,
                default = 0,
                desc = "Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.",
                validate = function(n)
                  return n >= -2 and n <= 2, "Must be between -2 and 2"
                end,
              },
              logit_bias = {
                order = 9,
                mapping = "parameters",
                type = "map",
                optional = true,
                default = nil,
                desc = "Modify the likelihood of specified tokens appearing in the completion. Maps tokens (specified by their token ID) to an associated bias value from -100 to 100. Use https://platform.openai.com/tokenizer to find token IDs.",
                subtype_key = {
                  type = "integer",
                },
                subtype = {
                  type = "integer",
                  validate = function(n)
                    return n >= -100 and n <= 100, "Must be between -100 and 100"
                  end,
                },
              },
            },
          })
        end,
      },
    },
    strategies = {
      agent = { adapter = "venice" },
      chat = { adapter = "venice" },
      inline = { adapter = "venice" },
    },
  })

[KyrillGobber]

Excellent, thank you!

Btw, you can toggle web search and reasoning as well. Just add:

                            venice_parameters = {
                                order = 9,
                                mapping = "parameters",
                                type = "object",
                                optional = true,
                                default = {
                                    disable_thinking = true,
                                    enable_web_search = 'on',
                                },
                                desc =
                                "Options to enable web search and disable think",
                            },

Change "order" to the order of of the parameter in your config.

Now we just need a way to toggle this on and off at runtime :P

EDIT: Actually, asking venice I got this way to make toggling on the fly work:
Declare global:

_G.codecompanion_adapters = {}
You can just put this on top of your codecompanion.lua or wherever your plugin config is.

function _G.toggle_venice_web_search()
    if not _G.codecompanion_adapters or not _G.codecompanion_adapters.venice then
        vim.notify("Venice adapter not initialized or stored", vim.log.levels.ERROR)
        return
    end

    local adapter = _G.codecompanion_adapters.venice
    local params = adapter.schema.venice_parameters.default
    params.enable_web_search = (params.enable_web_search == 'on') and 'off' or 'on'

    vim.notify("Venice web search: " .. params.enable_web_search, vim.log.levels.INFO)
end

vim.api.nvim_create_user_command("ToggleVeniceWebSearch", function()
    _G.toggle_venice_web_search()
end, {})

Now you can type :ToggleVeniceWebSearch to toggle web search. Or bind it to a keymap in the function or wherever you want.

If you only use one venice parameter, you can also use display.chat.show_settings, so that you have a header with the settings that you can switch on the fly. But that bugs out when you have multiple options like we have with disable_thinking and enable_web_search.