Hub MCP server
This server provides read-only discovery and use of the Healthier Business Hub API v2, plus webhook knowledge/helpers and bundled guide search.
Check Hub status and identity: live/sandbox environment, base URL, key name/prefix, scopes, write mode, toolsets, and last rate limit.
Search 189 Hub API v2 operations by text, portal/toolset, HTTP method, scope, or writes-only.
Describe a specific operation with parameters, body schema, required fields, scope, side effects, errors, and an example call.
Call permitted GET operations by id using path/query/body/fields/pagination; writes are refused because the server is read-only.
List and describe 59 webhook events for knowledge only.
Verify or compute Hub webhook signatures locally using HMAC-SHA256 and the timestamp tolerance window.
Search bundled Hub API and developer portal guides, including sandbox, keys, webhooks, and going-to-production guidance.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Hub MCP server check my Hub connection status and confirm I'm on the sandbox"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Hub MCP server
@healthier-business/hub-mcp is a Model Context Protocol server for the Healthier Business Hub API v2. It lets an AI assistant (Claude Code, Claude Desktop, Cursor, Codex, any MCP client) use every Hub endpoint: 213 operations across the Hub core and ten portals, plus the 73 webhook events as knowledge.
It is built to be safe by default:
Read-only until the owner turns writes on.
Sandbox first. Live is real people and real credits; the server always says which one you are on.
Live writes are a two-step: the first call returns a plan and sends nothing; the second needs the one-time
confirmation_tokenthe server issued with the plan (aconfirm: truethe model sends on its own does nothing on live).Keys never reach the model or a log. The API key comes only from the environment.
Package: @healthier-business/hub-mcp. Command: hb-hub-mcp. Needs Node 20 or newer.
Quickstart (sandbox first)
You need Node 20+, a sandbox base URL and a sandbox API key (hbk_test_...) from the developer portal. Sandboxes are separate from the Hub and hold synthetic data; see hb://guides/testing-and-sandbox. A live key is hbk_... from the Hub's Developer page.
Check your setup first (prints the mode and scopes, never the key):
HB_API_KEY=hbk_test_... HB_BASE_URL=https://YOUR-SANDBOX-URL npx -y @healthier-business/hub-mcp --doctorClaude Code
export HB_API_KEY=hbk_test_... # in your shell, not in chat
claude mcp add hb-hub --scope project \
--env HB_API_KEY="$HB_API_KEY" --env HB_BASE_URL="https://YOUR-SANDBOX-URL" --env HB_READ_ONLY=true \
-- npx -y @healthier-business/hub-mcpThen ask Claude to check the connection: "Run hb_status". It tells you whether you are on the sandbox or live, which key it is using and what the key may do.
Or install it as a Claude Code plugin. The plugin adds the server, a safe-workflow skill and two commands, /hb-hub:status and /hb-hub:sandbox-test. In Claude Code run:
/plugin marketplace add Healthier-Business/hb-mcp
/plugin install hb-hub@healthier-businessClaude Code then asks for your sandbox API key (it starts with hbk_test_ and is kept in your system's secure storage) and your sandbox base URL. Both come from your sandbox in the developer portal. To change them later, run /plugin configure hb-hub@healthier-business. The plugin has no default URL, so it never points at the live Hub by accident. HB_READ_ONLY, HB_ALLOW_LIVE_WRITES, HB_TOOL_MODE, HB_TASK_TOOLS, HB_UPLOAD_DIRS and HB_LOG_LEVEL are read from your shell if you want to change them (HB_UPLOAD_DIRS is empty by default: only the folder Claude Code was started in is readable by hb_verify_certificate).
Claude Desktop
Edit claude_desktop_config.json (Settings, Developer, Edit Config) and add this block. Desktop has no variable interpolation, so the key sits in that file: use a sandbox key here. Restart Claude Desktop.
{
"mcpServers": {
"hb-hub": {
"command": "npx",
"args": ["-y", "@healthier-business/hub-mcp"],
"env": {
"HB_API_KEY": "hbk_test_PASTE_YOUR_SANDBOX_KEY_HERE",
"HB_BASE_URL": "https://YOUR-SANDBOX-URL",
"HB_READ_ONLY": "true"
}
}
}
}Cursor
Project: save this as .cursor/mcp.json (it reads HB_API_KEY and HB_BASE_URL from your environment with ${env:...}). Global: ~/.cursor/mcp.json.
{
"mcpServers": {
"hb-hub": {
"command": "npx",
"args": ["-y", "@healthier-business/hub-mcp"],
"env": {
"HB_API_KEY": "${env:HB_API_KEY}",
"HB_BASE_URL": "${env:HB_BASE_URL}",
"HB_READ_ONLY": "true"
}
}
}
}One-click install link (fills in placeholders you must replace afterwards in Settings, MCP):
cursor://anysphere.cursor-deeplink/mcp/install?name=hb-hub&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBoZWFsdGhpZXItYnVzaW5lc3MvaHViLW1jcCJdLCJlbnYiOnsiSEJfQVBJX0tFWSI6IllPVVJfU0FOREJPWF9LRVkiLCJIQl9CQVNFX1VSTCI6Imh0dHBzOi8vWU9VUi1TQU5EQk9YLVVSTCJ9fQ%3D%3D
Codex
Add this to ~/.codex/config.toml:
[mcp_servers.hb-hub]
command = "npx"
args = ["-y", "@healthier-business/hub-mcp"]
env_vars = ["HB_API_KEY"] # forwarded from your shell
[mcp_servers.hb-hub.env]
HB_BASE_URL = "https://YOUR-SANDBOX-URL"
HB_READ_ONLY = "true"Any other client
stdio: command npx, args -y @healthier-business/hub-mcp, environment as in the table below. HTTP: hb-hub-mcp --http --port 3333 serves Streamable HTTP at http://127.0.0.1:3333/mcp.
Approval for sensitive areas
Occupational Health and DBS & Right To Work (by default; Hub staff choose the list) hold health and criminal record information. With a live key their API calls, and the webhook events of the same area, work only after Hub staff have approved your organisation. A user of your organisation asks for it once in the Hub under Developer > API access and is emailed the decision. A sandbox is always open, so nothing changes there.
See where you stand.
hb_statuslists each sensitive area with its state (approved,pending,not_requested,rejected,revoked, ornot_requiredin a sandbox) and warns for the ones the key cannot use yet. The operation behind it,account.api-access.show(GET /api/v2/account/api-access), is read-only, needs no scope and works with any valid key, in compact mode throughhb_call_operationand in full mode as the toolaccount_api_access_show.hb_go_live_checkfails for a sensitive area the key has a scope for that is not approved.Refusals are explained. A live call to an area without approval answers
403withapi_access_not_approved,api_access_pending,api_access_rejectedorapi_access_revoked, and creating a webhook endpoint with events of such an area answerswebhook_events_not_approved. The server turns these into plain words for the assistant, for example: "Occupational Health needs approval in the Hub under Developer > API access; status: pending", with the docs link and "do not retry". They are never retried.Descriptions say so. The tool and operation descriptions of Occupational Health and DBS & Right To Work, and of the task tools that use them, state that live use needs approval.
Before approval. A key can hold the scopes of these areas before approval; its calls to other areas work as normal. Events of an area are not sent, queued or replayed while it is not approved: fetch what you missed through the API.
Read the guide with hb://guides/api-access-approval.
Then go live
When it works in the sandbox, follow the go-live-checklist prompt (or hb://guides/going-live): create a live key with least-privilege scopes, point HB_BASE_URL at https://hub.hbcompliance.co.uk (or remove it), run --doctor, and keep HB_READ_ONLY=true until the owner is ready for live writes.
Related MCP server: vybeflow-mcp
Tools
Compact mode (default, HB_TOOL_MODE=compact): 8 tools plus the task tools
MCP clients degrade or cap beyond about 40 tools, so the default is a handful of meta tools that reach all 213 operations, plus curated task tools for the common jobs (below): 22 tools read-only and 38 with writes enabled (HB_TASK_TOOLS changes that).
Tool | What it does |
| Who am I: environment (live/sandbox), base URL, key name and prefix, scopes, whether writes are enabled, last rate limit, and the approval state of each sensitive area (see Approval for sensitive areas). |
| Search the operations by text, toolset (portal), method or scope. Says which are callable now and which the key's scopes allow. |
| Full detail: parameters, body schema with required fields and example, scope, credits, health data, errors, idempotency, a ready example call. |
| Call any operation by id with |
| The 73 webhook events (filter by portal or text). |
| One event: payload schema, sample, delivery headers, verification rule. |
| Local, no network: verify or compute |
| Local, no network, no key needed: keyword search over the 37 bundled guides (16 API, 21 developer portal); returns the best matches with a snippet and the |
Task tools (compact and full mode)
Task tools do a common job in one call with sensible defaults, so an assistant does not have to search, describe and call several operations. They run through the same pipeline as hb_call_operation (spec validation, read-only default, live-write gate, idempotency, secret redaction, size cap, error mapping), check the key's scopes first and only call what is allowed, name what they skipped and why, and list the operation ids they called (readable text first, then structured data). They respect HB_TOOLSETS (a task tool is hidden when its portals are not enabled) and HB_TASK_TOOLS (below).
Every task tool that writes is a two-call flow. The first call reads only and returns the options or the plan (who will be emailed, what credits or fees apply, a field-by-field diff for updates) and sends nothing. The second call, with the confirmation_token from the plan after the user agreed (a sandbox also accepts confirm: true), does it, with idempotency keys (the plan returns the key to reuse). This holds in a sandbox and on live; on live the server must also allow live writes (HB_READ_ONLY=false and HB_ALLOW_LIVE_WRITES=true). Write task tools are hidden while the server is read-only. Where a Hub call can email a real person, the plan says so.
Read tools (14):
Tool | What it does |
| Find candidates by name, email, own reference or |
| One line per record (status and dates) across online training, practical training, virtual BLS, references, DBS and right to work, registration monitoring, clinical appraisals, clinical interviews, certificate verifications (linked by |
| One candidate's online training: summary, courses with grade and dates, modules by status, practical results, one course in full, the assignable catalogue. |
| Bookings across practical training (with no-shows), virtual BLS, clinical interviews and clinical appraisals in one table; filter by portal, candidate, dates, status. No contact details. |
| Credits and balances for every portal the key can reach (including Training Verification: money, automated and manual credits, older balance), recent transactions, and the occupational health credit packages. |
| The key (name, expiry, scopes), credits and webhook health in one answer. |
| Failed webhooks, unacknowledged alerts, bookings awaiting payment, appraisals awaiting documents, lapsing training, expired reference requests, certificate verifications that failed or sit pending for over an hour, occupational health counts only. |
| Alerts from DBS/RTW, registration monitoring and occupational health with filters; one alert in full. Occupational health alerts are statuses only. |
| A DBS/RTW or registration worker: current result, last checks, evidence metadata (type, date, size). Masked certificate numbers only; no date of birth, contact details or files. |
| Usage (trial, billing type, estimate) and bills for DBS/RTW and registration monitoring. |
| Certificate and report details and exactly how to download them (practical, virtual BLS and online training certificates, interview report, appraisal evaluation report, occupational health reports list, and the Training Verification report and submitted certificate). File bytes are never returned. |
| Endpoints with active flag and consecutive failures, recent failed deliveries and a response code summary. URLs without query strings. |
| Readiness report: environment, key type, wildcard and expiry warnings, scopes against the |
| Follow certificate verifications: list (filter by status, request type, |
Write tools (16, two calls each):
Tool | What it does |
| Options, plan, then hold and book a practical training session; |
| Virtual BLS timeslot, clinical interview timeslot or clinical appraisal (param |
| Cancel (practical, virtual BLS, interviews, and |
| Practical training booking invitations: create, list (read-only), delete. One-time links are not shown. |
| Create (refuses a duplicate without |
| Assign online courses without removing existing ones unless named; optional reminder email. |
| Request references ( |
| Create an occupational health request from the request options; no health answers are handled. |
| Reference reminders, extend, cancel; occupational health and online training reminder emails; the plan lists who is contacted. |
| Add and verify a DBS/RTW or registration worker, or re-check one. Share codes and certificate numbers appear only masked and are scrubbed from errors. |
| Acknowledge DBS/RTW or registration alerts (one, ids, a type, or all open only when explicit); dismiss or clear occupational health alerts. |
| CSV import into DBS/RTW or registration monitoring: preview first (counts and row errors, no sample rows), then import. |
| Redeliver failed webhook deliveries (the plan lists them). |
| Rotate an endpoint's signing secret. The new secret is never returned: |
| Sandbox only: create an endpoint, send a test event, report the delivery. Refuses on live. Same secret handling ( |
| Verify a training certificate file (PDF, JPG or PNG) on this machine. Call 1 checks the file locally and shows file name, size, type and SHA-256, who gets the result email, the price (Automated is free for regular accounts, charged for verification-only accounts; Manual is always charged; credits or wallet, no card) and the balance, and sends nothing. Call 2 ( |
Not built as tools: submitting occupational health answers, deleting workers or endpoints, evidence upload, downloading a verification's certificate or report (hb_get_report says how), token operations (use hb_call_operation where allowed). Right to work document or passport uploads are not supported by hb_verify_worker (share codes are).
HB_TASK_TOOLS chooses how many task tools are offered: all (default, 30), core (11: hb_find_candidate, hb_candidate_overview, hb_account_summary, hb_needs_attention, hb_go_live_check, hb_book_practical_training, hb_setup_sandbox_webhook, hb_credits, hb_list_bookings, hb_webhook_health, hb_verification_status) or none. Tool counts in compact mode: all is 8 + 14 = 22 read-only and 8 + 30 = 38 with writes; core is 17 read-only and 19 with writes; none is 8. If your client caps tools around 40, all fits with writes on but leaves little room for other servers: use core.
Full mode (HB_TOOL_MODE=full)
One tool per operation, generated from the bundled spec, named from the operation id (hub.candidates.list becomes hub_candidates_list), plus hb_status, hb_list_events, hb_describe_event, hb_verify_webhook_signature, hb_search_guides and the task tools above. Path and query parameters are top-level arguments, body is the JSON body. Annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) come from the method and the spec's flags. While HB_READ_ONLY=true, write tools are hidden.
Toolset ( | Operations | Reads | Writes |
| 4 | 2 | 2 |
| 11 | 5 | 6 |
| 4 (1 exposed) | 1 | 3 |
| 24 | 16 | 8 |
| 32 | 24 | 8 |
| 11 | 5 | 6 |
| 20 | 14 | 6 |
| 14 | 9 | 5 |
| 13 | 8 | 5 |
| 29 | 17 | 12 |
| 32 | 19 | 13 |
| 8 | 7 | 1 |
| 11 | 9 | 2 |
Total | 213 | 136 | 77 |
Tool counts in full mode: all toolsets with writes on is 210 operation tools + 5 helpers + 30 task tools = 245; read-only (default) is 136 read tools + 5 + 14 task tools = 155 (auth.me is the only authentication tool). With HB_TASK_TOOLS=core that is 226 and 150 (writes on, read-only), with none 215 and 141. Use HB_TOOLSETS to stay under your client's limit, for example HB_TOOLSETS=hub,occupational-health.
The three credential operations (auth.token.create, auth.refresh.create, auth.revoke.create) are never exposed: the server exchanges the key and refreshes tokens itself, so a key or token never passes through a tool call.
Resources and prompts
Resources: hb://guides/<name> (the 16 API developer guides and 21 developer portal guides, 37 in all; API guides: authentication, errors, scopes-and-permissions, idempotency, webhooks, going-live, ...), hb://portals/<toolset>, hb://spec/overview, and templates hb://spec/operations/{id}, hb://spec/events/{type}.
Prompts: get-started-in-sandbox (sign up, sandbox, key, --doctor, first read), book-practical-training, check-candidate-compliance, webhook-sandbox-setup, go-live-checklist, onboard-candidate, verify-a-certificate (price and balance check, file check, submit, follow the status and the webhook).
Developer portal guides
The developer portal is where a developer signs up, makes sandboxes, test keys and webhooks, and uses the API Playground. Its 21 usage guides are bundled as resources hb://guides/portal-<name> (source files in content/guides/portal/), listed after the 16 API guides, so an assistant can explain the portal as well as the API. When no key is configured the server instructions, hb_status and the missing-key error point to the first three.
Resource | What it covers |
| What the Healthier Business developer portal is, what is in it and the shortest path from a new account to a working integration. |
| Sign up for the developer console with your work email address, every field of the form, the rules for passwords and email addresses, and what each error message means. |
| What the Check your inbox page does, how long the confirmation link lasts, how to get another email and what to do when it does not arrive. |
| Signing in, resetting a forgotten password, turning on two-step sign-in with an authenticator app, recovery codes, and how sessions and lockouts behave. |
| A walk through the console: the sidebar, the getting started checklist, the account menu, the theme switch, and how it looks on a phone. |
| Create, rename, reset and delete sandboxes, read their addresses and numbers, and understand what a sandbox contains and what it never does. |
| Create test keys with the access you need, see a key once, roll and delete it, then exchange it for an access token and refresh it. |
| Make your first calls to a sandbox with curl, import the OpenAPI document or Postman collection, and use variables so the same requests work against production later. |
| Register an https endpoint in a sandbox, choose events, keep the signing secret, verify every signature, test and simulate events, read the delivery log, and understand retries and automatic switch-off. |
| Look at every table of a sandbox, search and sort it, and open a record as an expandable JSON tree. |
| Make the things only a person or a clock can do happen inside a sandbox, such as a candidate paying or an interview ending, and see the webhook events, emails and data changes they cause. |
| Build and send requests to a sandbox from the console, exchange a key for a token, save requests in collections, use variables, read responses, copy code in four languages and switch to live calls. |
| Read every call your sandbox answered, filter by method and result, open a call to see both bodies, and work out why a call failed using the error code and request id. |
| See the emails and texts a sandbox would have sent to candidates, search and filter them, and turn on notifications on your own device. |
| Ask the API team a question from the console, read their answers, choose what you need (including a paid technical support call paid with HB Pay), and what to put in a message so it is answered quickly. |
| The checklist for moving an integration from a sandbox to the live HB Hub, doing it by hand or connecting your HB Hub account to manage production keys and webhooks from the console. |
| Your name, time zone and password, the account security page, downloading your data and deleting your account. |
| A step by step migration from the per-service legacy APIs to the single Hub API v2: what changes, how to try it in a sandbox now, and how to switch to live when the Compliance Hub is released. |
| How the developer site is laid out, how to search it, what is on an endpoint page, how Try it works, and the tools around the reference (Ask AI, Copy for LLM, llms.txt, OpenAPI). |
| The limits that apply to keys and tokens, every error code and what to do about it, retry rules and how idempotency keys make repeated creates safe. |
| Short answers to the questions developers ask most, grouped by the part of the portal, with where to look when something does not work. |
Environment variables
Variable | Default | Meaning |
| none | The |
|
| Live by default. A sandbox looks like |
| detected |
|
|
|
|
| all | Comma list of portals (full mode, and a limit on |
|
|
|
|
|
|
|
| Must be |
|
|
|
|
| Cap on one tool answer. Larger answers are cut with a notice (lists lose items first). |
|
| Per request timeout. |
| none | Default secret for |
| none (certificate upload is off) | Comma-separated absolute folders |
|
| The one absolute folder where |
| none | Bearer token required by |
|
| Defaults for |
CLI: hb-hub-mcp [--http [--port N] [--host H]] [--doctor] [--version] [--help].
Safety model
Rule | How |
Read-only by default | Every non-GET operation is refused with an explanation, and hidden in full mode. |
Writes need intent |
|
Live writes need two more things |
|
Nothing blind-retried | A write is never retried automatically. A dropped connection returns the |
Idempotency | Writes that support it get an |
Validation before sending | Path, query, headers and body are checked against the spec; a bad call sends nothing. |
Secrets | Key, tokens and webhook secrets are registered with a redactor that scrubs every tool answer and log line, even if the Hub echoes one. A webhook signing secret ( |
Health data | Operations flagged |
Size | Answers over |
Scope of tokens | One refresher per process (single-flight), the single-use refresh token is replaced the moment a new pair arrives, and the 10 a minute auth throttle and |
Credentials | Credential endpoints are not tools. |
Task tools | Same pipeline as |
Local files |
|
Untrusted Hub text | Names, notes, referee answers and other free text in an answer can be written by candidates or third parties. Every operation answer sits between |
Webhook destinations |
|
Base URL | The key and tokens go to |
HTTP transport |
|
Secret files |
|
Money is integer pence with a currency; credits are units. The tool descriptions say which operations use credits.
Egress and the key's IP allowlist
With the default stdio transport the server runs on the developer's own machine, so every Hub call leaves from that machine's public IP. If the key has an IP allowlist, the developer's own address must be on it (or the call fails with 403 ip_not_allowed, and the error says what to do). With --http on a server, the server's address is what the Hub sees. Sandboxes do not enforce an allowlist unless switched on.
Troubleshooting
Symptom | Fix |
Server not listed, or exits at once | Run |
| Put the key in the client's server |
| Wrong, regenerated or deleted key, or a sandbox key against the live URL (or the other way round). |
| Add the named scope to the key on the Developer page ( |
| The machine running the server is not on the key's allowlist (see the egress note). |
| The account does not use that portal. |
| A live key called Occupational Health or DBS & Right To Work and the organisation is not approved for it. A user of the organisation asks in the Hub under Developer > API access. |
| A webhook endpoint asked for events of an area that is not approved. Remove those events or get the area approved first. |
| Use a real |
| Fix the fields listed under |
| Wait |
"read-only" refusals | By design. Enable in a sandbox with |
Too many tools in the client | Use compact mode (default) or |
Answer cut off | Use |
Available Tools
8 toolshb_call_operationARead-onlyIdempotent
[LIVE Hub] Call any Hub API v2 operation by id. Validates against the spec before sending; adds an Idempotency-Key to writes; follows pagination with all_pages (capped). The server is READ-ONLY: only GET operations run; writes are refused. Put path parameters in path_params, filters in query, JSON in body. Use fields (dotted paths such as ["candidate_ref","name"]) to keep answers small. Credits are units; money is integer pence with a currency. Never ask the user for an API key in chat.
Inputs: operation_id (required), body, query, fields, +6 more.
hb_describe_eventARead-onlyIdempotent
Describe one webhook event: summary, delivery behaviour (retries), the data payload schema and a sample payload. Payloads hold ids, statuses, dates and a candidate_ref, never names, emails or health data. Knowledge only.
Inputs: event_type (required).
hb_describe_operationARead-onlyIdempotent
Full detail of one operation: parameters, body schema with required fields and an example, required scope, side effects (credits, health data, destructive, idempotency), documented errors, and a ready example call for hb_call_operation. Read this before any write.
Inputs: operation_id (required).
hb_list_eventsARead-onlyIdempotent
List the 59 webhook events Hub can send (type and one-line summary). Optionally filter by portal prefix (e.g. "occupational-health") or text. Knowledge only: sends nothing.
Inputs: query, portal.
hb_search_guidesARead-onlyIdempotent
Search the bundled guides by words and get the best matches with a snippet and the resource to read (hb://guides/). Covers the Hub API v2 developer guides and the developer portal guides (sign up, sandboxes, keys, webhooks, Playground, going to production). Knowledge only: sends nothing, needs no key.
Inputs: query (required), group, limit.
hb_search_operationsARead-onlyIdempotent
Search the 189 Hub API v2 operations by text, toolset (portal), method or scope. Returns id, method, path, summary, scope, flags (credits, health data, destructive) and whether each is callable now. Start here, then hb_describe_operation, then hb_call_operation.
Inputs: limit, query, scope, method, +2 more.
hb_statusARead-onlyIdempotent
Who am I and what may I do? Calls GET /auth/me and reports: environment (live or sandbox), base URL, key name and prefix, the key's scopes, whether writes are enabled, the toolsets, and the last-seen rate limit. Never reveals a key or token. Call this first.
Inputs: no named parameters.
hb_verify_webhook_signatureARead-onlyIdempotent
Pure local helper (no network): verify or compute a Hub webhook signature. The signature is "sha256=" plus the hex HMAC-SHA256 of "{timestamp}.{raw body}" with the endpoint secret; deliveries older or newer than 300 seconds are rejected. Pass the raw body byte-for-byte. The secret is read from HB_WEBHOOK_SECRET unless passed (prefer a sandbox secret if you pass it in chat). Omit signature to just compute it.
Inputs: body (required), timestamp (required), secret, signature, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool targets a distinct resource+action: auth introspection (hb_status), operation discovery (search/describe/call), webhook event discovery (list/describe), a local signature helper, and guide search. The search/describe/call trio is a classic progressive-disclosure pattern with explicitly stated ordering, so there is no realistic misselection. The only near-collision, hb_search_operations vs hb_search_guides, is cleanly separated by domain (API operations vs documentation).
All eight tools share the hb_ prefix and snake_case, and follow a predictable verb_noun pattern (search_operations, describe_operation, call_operation, list_events, describe_event, verify_webhook_signature, search_guides). hb_status is the sole noun-only name, but it is a conventional whoami alias and does not break the pattern meaningfully.
Eight tools is well within the sweet spot and each one earns its place: three for the operation lifecycle, two for webhook events, one local crypto helper, one knowledge search, one status check. The meta-tool design (search -> describe -> call) means a small surface covers 189 API operations without bloat.
The search/describe/call pattern gives effectively complete coverage of the 189-operation API surface, and webhook discovery plus signature verification covers the integration lifecycle. Minor gaps: no tool to read a guide's full content (hb_search_guides returns an hb:// resource reference, relying on MCP resources), and no webhook endpoint registration/management operations. The read-only refusal of writes is a documented server constraint rather than a surface gap.
Maintenance
Related MCP Connectors
Find and call verified APIs from any AI assistant, with free trial calls and previewed writes.
Connect assistants to your company tools with per-person, per-action grants and a full audit log.
Connect AI to store orders, products and inventory with scoped access and human approvals.
Connect assistants to your workspace knowledge, skills, and work tools.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with SMB platform APIs for querying business data, managing tasks, accessing connectors, dashboards, and monitoring security.16MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to securely connect to a vybeflow tenant for multi-channel messaging operations such as reading inbox tickets, looking up contacts, checking campaign progress, and sending messages under scoped permissions.MIT
- AlicenseAqualityCmaintenanceEnables AI assistants to work with the entire Manager.io API surface across any number of businesses, with granular per-resource controls that can block, require confirmation, or allow operations. It surfaces real confirmation dialogs before risky writes and keeps security-sensitive endpoints read-only.13MIT

Marsell MCPofficial
AlicenseNot gradedqualityBmaintenanceEnables AI clients to read and act on projects, brand and market data, people, analytics, decisions, and token balances, with scoped permissions for content, marketing, sales workflows, image creation, business setup, missions, and browser-based messaging.MIT