MCP Hub v5.13.0: Granular Tool Access

[ravitemer]

Cross-posted from ravitemer/mcphub.nvim#202

What’s going on with my ‘boys’ and, in some cases, ‘gals?’ 😂

This update introduces a significant improvement to the MCPHub-CodeCompanion integration, providing much more flexibility and control over your MCP tools.

Demo: Fixing an issue using Github MCP Server

fix-issue.mp4

Configs used in the above Video Demo

Github MCP Server Config

{
  "github": {
    "url": "https://api.githubcopilot.com/mcp/",
    "headers": {
      "Authorization": "Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}"
    }
  }
}

Blink.cmp config

return {
  "saghen/blink.cmp",
  ---@module 'blink.cmp'
  ---@type blink.cmp.Config
  opts = {
    appearance = { nerd_font_variant = "mono" },
    signature = {
      enabled = true,
      trigger = {
        show_on_keyword = true,
        blocked_trigger_characters = {},
        blocked_retrigger_characters = {},
        show_on_trigger_character = true,
        show_on_accept = true,
        show_on_accept_on_trigger_character = true,
        show_on_insert_on_trigger_character = true,
        show_on_insert = true,
      },
      window = {
        border = "rounded",
        show_documentation = true,
      },
    },
    completion = {
      trigger = {
        show_in_snippet = false,
        show_on_backspace = true,
        show_on_backspace_in_keyword = false,
      },
      list = {
        selection = {
          auto_insert = true,
          preselect = true,
        },
      },
      accept = {
        auto_brackets = {
          default_brackets = { "(", ")", "[", "]", "{", "}", '"', "'", "`" },
          enabled = true,
        },
      },
      documentation = {
        auto_show = true,
        auto_show_delay_ms = 100,
        update_delay_ms = 50,
        treesitter_highlighting = true,
        draw = function(opts) opts.default_implementation() end,
        window = {
          min_width = 10,
          max_width = 60,
          max_height = 80,
          border = "rounded",
        },
      },
      menu = {
        auto_show = true,
        border = "rounded",
        winhighlight = "Normal:NormalFloat,FloatBorder:FloatBorder,CursorLine:PmenuSel,Search:None",
        draw = {
          padding = 2,
          gap = 2,
          treesitter = { "lsp" },
          cursorline_priority = 0,
          columns = { { "kind_icon" }, { "label", "source_name", gap = 1 } },
          components = {
            kind_icon = {
              text = function(ctx)
                local data = ctx.source_id == "codecompanion" and ctx.item.data
                if data then return data.type == "variable" and "" or data.type == "tool" and "󱁤" or "󰿠" end
                local is_copilot = ctx.source_id == "copilot"
                if is_copilot then return " " end
                local kind_icon, _, _ = require("mini.icons").get("lsp", ctx.kind)
                return kind_icon
              end,
              highlight = function(ctx)
                local is_copilot = ctx.source_id == "copilot"
                if is_copilot then return "Special" end
                local _, hl, _ = require("mini.icons").get("lsp", ctx.kind)
                return hl
              end,
            },
            source_name = {
              text = function(ctx) return vim.tbl_get(map, ctx.source_id, "icon") or ctx.source_name end,
              highlight = function(ctx) return vim.tbl_get(map, ctx.source_id, "hl") or "Comment" end,
            },
          },
        },
      },
    },
  },
}

Adding files to chat using `.` with `nvim-tree`

return {
  "nvim-tree/nvim-tree.lua",
  config = function()
    local nvim_tree = require "nvim-tree"

    -- Define your custom on_attach function
    local function on_attach(bufnr)
      local api = require "nvim-tree.api"
      local luv = vim.loop

      local function add_reference(chat, path)
        local filemod = require "codecompanion.strategies.chat.slash_commands.file"
        local slash_command = filemod.new {
          Chat = chat,
          config = {},
          context = {},
          opts = {},
        }
        slash_command:output {
          path = path,
        }
      end

      -- Function to recursively add files in a directory to chat references
      local function traverse_directory(path, chat)
        local handle, err = luv.fs_scandir(path)
        if not handle then return print("Error scanning directory: " .. err) end

        while true do
          local name, type = luv.fs_scandir_next(handle)
          if not name then break end

          local item_path = path .. "/" .. name
          if type == "file" then
            -- add the file to references
            add_reference(chat, item_path)
          elseif type == "directory" then
            -- recursive call for a subdirectory
            traverse_directory(item_path, chat)
          end
        end
      end

      -- Attach default mappings
      api.config.mappings.default_on_attach(bufnr)

      -- CodeCompanion integration
      vim.keymap.set("n", ".", function()
        local node = api.tree.get_node_under_cursor()
        local path = node.absolute_path
        local codecompanion = require "codecompanion"
        local chat = codecompanion.last_chat()

        -- create chat if none exists
        if chat == nil then chat = codecompanion.chat() end

        local attr = luv.fs_stat(path)
        if attr and attr.type == "directory" then
          -- Recursively traverse the directory
          traverse_directory(path, chat)
        else
          -- if already added, ignore
          for _, ref in ipairs(chat.refs) do
            if ref.path == path then return print "Already added" end
          end
          add_reference(chat, path)
        end
      end, { buffer = bufnr, desc = "Add or Pin file to Chat" })
    end

    nvim_tree.setup {
     on_attach = on_attach 
   }
  }

Previous Limitations with @mcp

The existing @mcp tool worked, but it had some drawbacks:

• System prompt pollution: All MCP servers were dumped into the system prompt.
• Model compatibility issues: Some models struggle with schema-heavy system prompts.
• Manual server management: Required toggling servers on/off before use.
• Lack of precision: No way to target specific tools or create focused workflows.

✨ New: Granular Tool Access

This update introduces granular tool access, which creates proper CodeCompanion function tools for each MCP server and tool, enabling more powerful and precise workflows.

🎯 Server Groups

Access all tools from a specific server:

@github Handle this entire PR workflow
@neovim Manage all file operations
@fetch Gather information from various URLs

🔧 Individual Tools

Target specific functionality with namespaced tools:

@neovim__read_file Show me the configuration
@github__create_issue File a bug report
@github__create_pull_request Submit this fix

🛠️ Custom Tool Combinations

Create specialized workflows by mixing tools from different servers in your CodeCompanion config:

require("codecompanion").setup({
  strategies = {
    chat = {
      tools = {
        groups = {
          ["github_pr_workflow"] = {
            description = "GitHub operations from issue to PR",
            tools = {
              -- File operations
              "neovim__read_multiple_files", "neovim__write_file", "neovim__edit_file",
              -- GitHub operations
              "github__list_issues", "github__get_issue", "github__get_issue_comments",
              "github__create_issue", "github__create_pull_request", "github__get_file_contents",
              "github__create_or_update_file",  "github__search_code"             
            },
          },
        },
      },
    },
  },
})

🎛️ Fine-Grained Auto-Approval

One of the standout features is per-tool auto-approval control. Configure which tools run automatically versus requiring confirmation directly from the Hub UI by pressing a on a tool or an entire server. This is perfect for allowing safe operations (read_file, search_code) while protecting potentially destructive ones (delete_items, execute_command).

🚀 Benefits

• Better Performance: No more system prompt pollution. Models receive focused, function-callable tools.
• Enhanced Precision: Target exactly the tools you need for a given task.
• Improved Workflow: No need to manually toggle servers. Start them once and access any tool on demand.

⚠️ Note

Some older OpenAI models have character limits for function descriptions. If you encounter issues, consider using latest models or falling back to the general @mcp group for specific cases.

🚀 Get Started

No breaking changes! The traditional @mcp tool continues to work exactly as before. These new features are purely additive.

1. Update mcphub.nvim
2. Ensure your CodeCompanion config includes the mcphub extension. The default options enable all new features.

   require("codecompanion").setup({
       extensions = {
         mcphub = {
           callback = "mcphub.extensions.codecompanion",
           opts = {
               -- MCP Tools 
               make_tools = true,              -- Make individual tools (@server__tool) and server groups (@server) from MCP servers
               show_server_tools_in_chat = true, -- Show individual tools in chat completion (when make_tools=true)
               add_mcp_prefix_to_tool_names = false, -- Add mcp__ prefix (e.g `@mcp__github`, `@mcp__neovim__list_issues`)
               show_result_in_chat = true,      -- Show tool results directly in chat buffer
               -- MCP Resources
               make_vars = true,                -- Convert MCP resources to #variables for prompts
               -- MCP Prompts 
               make_slash_commands = true,      -- Add MCP prompts as /slash commands
           }
         }
       }
   })

3. Discover available server groups (@github) and individual tools (@github__create_issue) with @ completion in the CodeCompanion chat.
4. Use the Hub UI (:MCPHub) to configure auto-approval for your most trusted tools.

⚡ Better Built-in Neovim Tools: edit_file & write_file

The built-in neovim server is now more powerful with two new tools:

• write_file: A tool to write content to a file, showing an interactive diff by default.
• edit_file: An advanced, interactive tool for making precise file modifications using SEARCH/REPLACE blocks.

The edit_file tool is highly customizable through your mcphub setup. For a smoother, uninterrupted workflow, you can auto-approve these tools in the Hub UI. When auto-approved, they will apply changes directly without showing the interactive diff.

require("mcphub").setup({
    builtin_tools = {
        edit_file = {
            parser = {
                track_issues = true,              -- Track parsing issues for LLM feedback
                extract_inline_content = true,   -- Handle content on marker lines
            },
            locator = {
                fuzzy_threshold = 0.8,           -- Minimum similarity for fuzzy matches (0.0-1.0)
                enable_fuzzy_matching = true,    -- Allow fuzzy matching when exact fails
            },
            ui = {
                go_to_origin_on_complete = true, -- Jump back to original file on completion
                keybindings = {
                    accept = ".",                 -- Accept current change
                    reject = ",",                 -- Reject current change
                    next = "n",                   -- Next diff
                    prev = "p",                   -- Previous diff
                    accept_all = "ga",           -- Accept all remaining changes
                    reject_all = "gr",           -- Reject all remaining changes
                },
            },
            feedback = {
                include_parser_feedback = true,   -- Include parsing feedback for LLM
                include_locator_feedback = true,  -- Include location feedback for LLM
                include_ui_summary = true,        -- Include UI interaction summary
                ui = {
                    include_session_summary = true,     -- Include session summary in feedback
                    include_final_diff = true,          -- Include final diff in feedback
                    send_diagnostics = true,            -- Include diagnostics after editing
                    wait_for_diagnostics = 500,         -- Wait time for diagnostics (ms)
                    diagnostic_severity = vim.diagnostic.severity.WARN, -- Min severity to include
                },
            },
        },
    },
})

[Jufralice]

That's a huge improvement! I was actually avoiding using the @mcp tool because of the limitations that you described.
This granular approach is exactly what I was dreaming of!
Great job and thanks a lot! This is a real game changer!
🥳 🙏