manager-mcp
Click on "Install 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., "@manager-mcpWho owes me money?"
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.
manager-mcp
MCP server for self-hosted Manager.io: ask your AI about invoices, balances, and books.
What is Manager.io?
Manager.io is free, self-hosted accounting software for Windows, macOS, and Linux (also available as Cloud Edition). It covers sales, purchases, banking, payroll, and the full ledger, with an HTTP API (/api2) for automation.
This project wires that API into the Model Context Protocol so Cursor, Claude, VS Code Copilot, and other MCP hosts can query your live books in natural language.
Useful Manager.io links:
Related MCP server: QuickBooks Online MCP Server
What this server does
Default is read-only. You get:
10 read tools - discovery, six searchable collections, seven report shortcuts
Task tools (opt-in) - intent-shaped writes such as
record_customer_payment,issue_sales_invoice,record_customer_deposit(register when matching write scopes are set)Deprecated CRUD tools - per-resource
create_*/update_*/delete_*still register under scopes until 0.3.0; prefer task toolsrawescape hatch - restores the full CRUD set for advanced useHard denylist - access tokens, chart of accounts forms, tax/currency, email templates, and similar high-risk paths stay blocked even when writes are on
Transport is stdio. No HTTP server. No global install required if you use uv / uvx.
Branding / icons
stdio hosts (Cursor, Claude Desktop via
mcp.json): the server advertises Manager branding in MCPserverInfo.icons(embedded PNG data URI, plus a GitHub raw HTTPS fallback).Cursor plugin:
.cursor-plugin/plugin.jsonusesdocs/manager-icon.svg.Claude Desktop Extension: pack
mcpb/(includesicon.png). See Installation → Claude Desktop below.Claude.ai remote connectors: Claude.ai ignores
serverInfo.iconsand uses the root-domain favicon of the connector URL. If you host a remote MCP later, servedocs/favicon.icoat the registrable domain root (e.g.https://acme.com/favicon.icoforhttps://mcp.acme.com/...).
Requirements
Python ≥ 3.10 (pulled in automatically by
uvx)uv (provides
uvx)A reachable Manager.io API:
MANAGER_API_URL+MANAGER_API_KEY
Access token
In Manager, open Settings → Access Tokens.
Create a token and copy the value into
MANAGER_API_KEY.Set
MANAGER_API_URLto your API base (desktop oftenhttp://127.0.0.1:55667/api2).
manager-mcp sends the token as the X-API-KEY header. Full walkthrough: Access Tokens.
Quick start
Run the PyPI package with uvx:
uvx manager-mcpPaste a client config below, set MANAGER_API_URL / MANAGER_API_KEY, restart the host, then ask: “Who owes me money?” or “Show bank balances.”
From a git clone (dev): uvx --from git+https://github.com/flumpiey/manager-mcp manager-mcp or uv run --directory /path/to/manager-mcp manager-mcp.
Installation
Configs below pull manager-mcp from PyPI. Leave write-scope env vars unset for read-only.
Plugin (Configure UI for URL, key, and scopes): this repo is a Cursor plugin via .cursor-plugin/plugin.json + root mcp.json.
Symlink or copy the clone to
~/.cursor/plugins/local/manager-mcp(Windows:%USERPROFILE%\.cursor\plugins\local\manager-mcp).Reload the window.
Open Plugins → Configure on
manager-mcp. Set Manager API URL and Manager API key. Leave Write scopes / Delete scopes empty for read-only, or paste a CSV such asquotesorquotes,orders.Confirm the
managerMCP server is enabled under Customize / MCP.
Marketplace listing is a separate submit at cursor.com/marketplace/publish.
Manual mcp.json: project .cursor/mcp.json or user-wide ~/.cursor/mcp.json.
From PyPI:
{
"mcpServers": {
"manager": {
"type": "stdio",
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Local editable (dev):
{
"mcpServers": {
"manager": {
"type": "stdio",
"command": "uv",
"args": ["run", "--directory", "/path/to/manager-mcp", "manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Optional scoped writes in the env block:
"MANAGER_MCP_WRITE_SCOPES": "quotes",
"MANAGER_MCP_DELETE_SCOPES": "quotes"Restart Cursor after saving. Confirm manager under MCP settings.
Desktop Extension (.mcpb): download mcpb.mcpb from GitHub Releases. Use v0.2.6 or later.
Open Claude Desktop → Settings → Extensions.
Open Advanced settings → Install Extension…
Select
mcpb.mcpb. Review permissions, enter Manager API URL and Manager API key, then click Install.Leave Write scopes and Delete scopes empty for read-only.
Restart Claude Desktop if tools do not appear.
Build your own bundle from a clone:
npx @anthropic-ai/mcpb pack mcpbOn Windows, double-click often does nothing and dragging the file into chat attaches it to the conversation instead of installing it. Use Install Extension… in Settings.
Manual mcp.json config: edit the Claude Desktop config, then restart the app.
OS | Path |
macOS |
|
Windows |
|
{
"mcpServers": {
"manager": {
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Local clone:
{
"mcpServers": {
"manager": {
"command": "uv",
"args": ["run", "--directory", "/path/to/manager-mcp", "manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Add via CLI:
claude mcp add manager --env MANAGER_API_URL=http://127.0.0.1:55667/api2 --env MANAGER_API_KEY=your-token -- uvx manager-mcpOr edit ~/.claude.json / project MCP config:
{
"mcpServers": {
"manager": {
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Create .vscode/mcp.json in the project root:
{
"servers": {
"manager": {
"type": "stdio",
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Local editable:
{
"servers": {
"manager": {
"type": "stdio",
"command": "uv",
"args": ["run", "--directory", "/path/to/manager-mcp", "manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Reload the window. Open Copilot Chat and confirm the manager tools are available.
Edit ~/.codeium/windsurf/mcp_config.json (macOS/Linux) or the Windsurf MCP settings UI:
{
"mcpServers": {
"manager": {
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Restart Windsurf after saving.
Add under context_servers in Zed settings.json (Agent Panel → settings also works):
{
"context_servers": {
"manager": {
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}Edit the Cline MCP settings file (cline_mcp_settings.json via the Cline MCP UI):
{
"mcpServers": {
"manager": {
"command": "uvx",
"args": ["manager-mcp"],
"env": {
"MANAGER_API_URL": "http://127.0.0.1:55667/api2",
"MANAGER_API_KEY": "your-token"
}
}
}
}In .continue/config.yaml:
mcpServers:
- name: manager
command: uvx
args:
- manager-mcp
env:
MANAGER_API_URL: http://127.0.0.1:55667/api2
MANAGER_API_KEY: your-tokenAny host that can spawn a stdio MCP server:
Field | Value |
Command |
|
Args |
|
Env |
|
uvx manager-mcpDev from a clone: uv run --directory /path/to/manager-mcp manager-mcp.
npx only runs npm packages. This is a Python package; use uvx.
Environment
Variable | Required | Notes |
| yes | Opaque base URL (include |
| yes | Sent as |
| no | Comma-separated domains for create/update. Empty = no writes. |
| no | Comma-separated domains for delete only. Never implied by WRITE_SCOPES. |
Valid scopes: quotes, orders, parties, items, sales, purchases, banking, payroll, ledger, raw. No wildcards (*, all).
Recommended (covers most bookkeeping without 82 tools):
"MANAGER_MCP_WRITE_SCOPES": "banking,sales,parties",
"MANAGER_MCP_DELETE_SCOPES": "sales,banking"Default with no scopes: 10 tools. All nine domain scopes plus every CRUD verb: up to 82 tools. Use raw only when you need the full CRUD escape hatch.
Legacy MANAGER_MCP_ALLOW_WRITES / ALLOW_WRITES / MANAGER_MCP_WRITES hard-fail if set. Use the scoped vars instead.
See .env.example. Prefer a secret manager for the API key in production configs.
Write scopes and task tools
When a scope is listed in MANAGER_MCP_WRITE_SCOPES, the server registers task tools for that domain plus deprecated CRUD twins. MANAGER_MCP_DELETE_SCOPES enables void_document and delete_* per domain.
Task tools (preferred)
Tool | Scopes | Purpose |
| parties | Single-resource party setup |
| sales | Issue invoice with inline lines |
| purchases | Issue purchase invoice |
| quotes | Issue sales or purchase quote |
| quotes + sales | Convert quote to invoice |
| banking | Receipt + invoice allocation |
| banking | Payment + invoice allocation |
| payroll and/or purchases | Expense claim or purchase invoice |
| banking | Inter-account transfer |
| ledger | Generic journal entry |
| matching delete scope | Void by resource name + key |
| banking | Deposit before invoice exists |
| quotes | Deposit document (quote) |
| ledger | Apply deposit via journal |
Bodies for composite tools use Manager-native JSON where noted. Clone get_record templates; do not invent field names.
Deprecated CRUD (0.2.0, removed 0.3.0)
Per-resource create_* / update_* / delete_* still register when their domain scope is enabled. Descriptions are prefixed [DEPRECATED in 0.2.0; use task tools] except create_customer / create_supplier. Set raw in MANAGER_MCP_WRITE_SCOPES to register CRUD without deprecation prefixes.
Scope | Resources (CRUD when enabled) |
| sales_quotes, purchase_quotes |
| sales_orders, purchase_orders |
| customers, suppliers |
| inventory_items, non_inventory_items |
| sales_invoices, credit_notes, delivery_notes |
| purchase_invoices, debit_notes, goods_receipts |
| receipts, payments, inter_account_transfers, bank_accounts |
| employees, payslips, expense_claims |
| journal_entries, depreciation_entries, amortization_entries |
Example with recommended scopes only:
"MANAGER_MCP_WRITE_SCOPES": "banking,sales,parties",
"MANAGER_MCP_DELETE_SCOPES": "sales"Denylist (always blocked): access-token forms, chart-of-accounts / *-account-form (except bank-or-cash), bank reconciliation, customer portal, starting balances, tax codes, exchange rates, currencies, custom fields/buttons, themes, email templates/settings.
Customer deposit workflow
A deposit is not revenue. Money received before delivery must not be booked to an income account. Confirm tax/VAT treatment with your accountant.
Ensure a Customer deposits bank/cash account exists in Manager (Settings → Bank and Cash Accounts).
record_customer_deposit- posts cash to that account. If the account is missing, the tool returnsprecondition_failedwith exact setup steps (Option A: guide only, no auto-create).issue_deposit_invoice(optional) - quote styled as a deposit document for the customer.issue_sales_invoicewhen the real invoice is raised.apply_deposit_to_invoice- journal entry moving deposit balance to the invoice (clone an existing journal viaget_record).
Required scopes: banking, quotes (deposit doc), ledger (apply), sales (final invoice via MCP).
Migration from 0.1.x
0.2.0: Task tools added; CRUD tools deprecated but still present under scopes.
0.3.0: CRUD tools removed (except
create_customer/create_supplier). Use task tools orrawscope.Update
MANAGER_MCP_WRITE_SCOPESto the recommended narrow set above instead of enabling all domains.
Tools
Read tools
Tool | Purpose | Period ( |
| Discovery; reports | n/a |
| Search/page a curated collection | n/a |
| Fetch one record via | n/a |
| Outstanding / aging customers | Accepted; may be unsupported on this view |
| Aging suppliers | Accepted; may be unsupported on this view |
| Bank/cash balances snapshot | Accepted; may be unsupported on this view |
| Trial balance | Forwarded as |
| P&L | Forwarded as |
| Balance sheet | Forwarded as |
| Tax summary | Accepted; may be unsupported on this view |
Collections for list_records / get_record: customers, suppliers, sales_invoices, purchase_invoices, chart_of_accounts, bank_accounts.
chart_of_accounts is list/search only (no single-form GET).
Bank dual path (intentional): bank_balances answers “what are my balances?”; list_records / get_record on bank_accounts answers “find account X and show detail.”
Write tools (deprecated)
Registered only for resources in enabled scopes. Prefer task tools above.
Pattern | Requires | Notes |
| write scope | Deprecated in 0.2.0 |
| write scope | Deprecated in 0.2.0 |
| delete scope | Deprecated in 0.2.0; use |
Agent Skill
Companion skill: skills/manager-accounting/SKILL.md.
The Cursor plugin discovers this skill from skills/. Without the plugin, copy or symlink that folder into your agent skills path. It tells the model to call list_resources first, verify after writes, and which report tools to prefer.
Development
uv sync --extra dev
uv run manager-mcpOffline tests only (respx). No live Manager required:
uv run ruff check src tests
uv run pytestGitHub Actions matrix: Python 3.10 and 3.12.
Caveats
One process ↔ one
MANAGER_API_URL. Multi-instance routing is out of scope.Multi-business disambiguation on a shared host is unverified. Do not claim multi-business support until validated against a live multi-business setup.
Vendored
src/manager_mcp/spec/api2.jsonis provenance only; runtime always hits the live URL.ChatGPT Apps need a hosted HTTP MCP endpoint. This package is stdio-only.
License
MIT. See LICENSE.
Available Tools
10 toolsaged_payablesC
Aged payables snapshot (read-only).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden; it does by explicitly stating 'read-only', which rules out side effects and makes the tool safe to invoke. The word 'snapshot' also discloses that the result is a point-in-time view rather than a live account balance, though auth and date-range defaults remain unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one short, front-loaded sentence with no waste; 'aged payables', 'snapshot', and 'read-only' all carry meaning. It is concise, though so brief that it leaves substantial context to be supplied elsewhere.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists and the tool has only two optional parameters, the description fails to explain the date semantics or the intended selection criteria relative to sibling reports. For a tool with no annotations and no parameter descriptions, this is not enough for confident invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description says nothing about 'from_date' or 'to_date'. The agent cannot determine whether 'to_date' is the aging cutoff, whether 'from_date' filters transactions in the period, or how null defaults behave.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The phrase 'Aged payables snapshot' clearly names a standard accounting report and, by specifying 'payables', differentiates it from the sibling 'aged_receivables'. It lacks a direct retrieval verb, but 'snapshot' plus 'read-only' conveys that the tool returns a point-in-time view.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to call this tool rather than 'aged_receivables', 'trial_balance', or the other financial-report siblings. The only usage cue is the tool name and description phrase itself, so the agent must infer the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
aged_receivablesB
Aged receivables / outstanding customer balances (read-only snapshot).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The phrase 'read-only snapshot' communicates that the tool is non-mutating and represents a point-in-time balance, which is useful since no annotations are provided. However, it does not disclose date-range behavior, aging-bucket semantics, or whether the snapshot reflects a specific as-of date. For a read-only report this is minimal but arguably sufficient at a basic level.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no filler and leads with the resource name. The paraphrase 'outstanding customer balances' adds clarity but is slightly redundant with 'aged receivables.' It earns a strong score for brevity, though it could have used the saved space for parameter or usage detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, with only two optional date fields and an output schema, so the minimal description may be enough for basic identification. However, without usage guidance or date-range semantics, it is not fully complete. It sits at the minimum viable level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention from_date or to_date at all. The parameter names are self-explanatory, but the meaning of the date range, defaults, and interpretation (e.g., inclusive boundaries, as-of date) is absent. The description fails to compensate for the undocumented parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource ('aged receivables') and clarifies it as 'outstanding customer balances,' with 'read-only snapshot' indicating the operation type. It distinguishes from siblings like aged_payables by specifying customer balances, though it lacks an explicit verb like 'retrieve' or 'list.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives; it does not mention aged_payables, list_records, or other report tools. The only context is 'read-only snapshot,' which implies a reporting use but does not state conditions for choosing it. This leaves the agent to infer selection from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
balance_sheetC
Balance sheet snapshot (read-only).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral burden and does state that the tool is 'read-only' and returns a 'snapshot,' which implies a non-mutating, point-in-time report. However, it does not explain how from_date/to_date affect the snapshot or what is included, so behavioral disclosure is partial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with the core meaning, with no wasted words. However, it is so sparse that important context is missing, which prevents a perfect conciseness score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists, the description omits essential selection and invocation context: what the date parameters do, how the snapshot is scoped, and how this differs from sibling financial reports. A tool with two optional parameters and several closely related siblings needs more.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention either parameter. The agent receives no meaning beyond the raw schema definitions of from_date and to_date, so the description fails to compensate for the total lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the specific financial statement (balance sheet) and signals a point-in-time, read-only snapshot. It is not a pure tautology, and the resource name differentiates it from siblings like trial_balance or profit_and_loss, though it lacks an explicit verb such as 'retrieves'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use balance_sheet versus alternatives like trial_balance or profit_and_loss. The description provides no context, exclusions, or explicit selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bank_balancesB
Bank/cash balances snapshot (read-only). For search/drill-in of individual accounts use list_records/get_record on bank_accounts.
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose a key trait: the operation is read-only and provides a snapshot. But it does not explain the effect of from_date/to_date on the snapshot, whether balances are current or as-of a date, or any other behavioral limitations such as data scope or aggregation behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences with no filler. The purpose is front-loaded, and the pointer to alternative tools is placed in the second sentence. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the return shape does not need to be explained in the description. The description covers the high-level purpose and read-only nature, but leaves a material gap around the two date parameters and their semantics. For a simple tool this is close to sufficient, but the missing date behavior prevents it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention to_date or from_date at all. The parameter names are somewhat self-explanatory, but the description adds no meaning beyond the raw schema, leaving the agent to guess date format, default behavior, or how the balance snapshot is filtered. For a tool with low schema coverage, the description needed to compensate and did not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource ('bank/cash balances') and signals that the tool provides a read-only snapshot, which clearly conveys that it retrieves balance data. It also distinguishes itself from list_records/get_record on bank_accounts for individual account drill-in. However, it uses a noun phrase rather than an explicit verb like 'get' or 'list', so it is slightly less direct than a fully explicit purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells agents when NOT to use this tool (for individual account search/drill-in) and names the alternative tools (list_records/get_record on bank_accounts). It does not, however, explicitly contrast this tool with other financial report siblings like balance_sheet, profit_and_loss, or trial_balance, so usage guidance is strong but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recordA
Fetch one collection record by GUID via Manager form endpoint (e.g. /customer-form/{key}). chart_of_accounts has no single form. For bank/cash account detail use resource=bank_accounts (not bank_balances).
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | ||
| resource | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it adds useful behavioral context: it identifies the endpoint pattern and resource-specific constraints. 'Fetch' clearly signals a read operation, though it stops short of describing error behavior or authorization needs, which are less critical here.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only three sentences, with the primary purpose front-loaded and caveats kept separate. Every sentence adds value without redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with an output schema, the description explains both parameters and critical resource caveats. It does not enumerate all valid resource values, but the output schema and sibling list_resources tool fill that gap acceptably.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
In the absence of parameter descriptions, the description adds meaning by specifying that 'key' is a GUID and that 'resource' selects the collection, with explicit examples like resource=bank_accounts. While not exhaustive, it gives enough semantic grounding for both required parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it fetches one collection record by GUID via a Manager form endpoint, giving a concrete example path. It distinguishes this from list-oriented tools and explicitly notes chart_of_accounts has no single form, which reinforces its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides concrete guidance by noting chart_of_accounts has no single form and that bank/cash account detail should use resource=bank_accounts rather than bank_balances. It does not explicitly contrast with sibling list tools like list_records, but the focus on one record by GUID implies the appropriate usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_recordsA
Search/page a curated collection. Core: customers, suppliers, sales_invoices, purchase_invoices, chart_of_accounts, bank_accounts. Also writable domains when present in discovery (e.g. receipts, payments, sales_quotes). bank_accounts is the searchable collection; use bank_balances for snapshot balances.
| Name | Required | Description | Default |
|---|---|---|---|
| skip | No | ||
| term | No | ||
| sort_by | No | ||
| resource | Yes | ||
| page_size | No | ||
| sort_by_desc | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral disclosure burden. It implies read/search behavior and clarifies that bank_accounts is the searchable collection, but it does not state whether the operation is read-only, how dynamic resource discovery works, or what side effects or permissions are involved. The phrase 'writable domains' is ambiguous and could be misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loads the core action and resource list, and includes a valuable routing note about bank_balances. The 'writable domains' phrasing is slightly vague, but the overall length and structure are appropriate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the most important resource enumeration and the bank_balances distinction, and an output schema exists, so return-value details are not needed. However, it leaves the relationship to list_resources and get_record unaddressed and omits behavioral or permission context, making it only partially complete for a six-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does partially by listing valid values for the required resource parameter, including core and optional domains. But it offers no guidance on term, sort_by, page_size, skip, or sort_by_desc beyond their self-explanatory schema names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action ('Search/page') and a concrete resource set, enumerating core collections like customers, suppliers, sales_invoices, and bank_accounts. It also distinguishes bank_accounts from bank_balances, making its scope clear relative to at least one sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context by naming the core searchable collections and explicitly directing snapshot-balance needs to bank_balances: 'use bank_balances for snapshot balances.' However, it does not explain when to prefer list_records over list_resources or get_record, so guidance is not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_resourcesA
List curated Manager.io capabilities. Default is read-only (10 tools). Task tools register when write scopes match; CRUD tools are deprecated unless raw scope is set.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It meaningfully discloses that the default output is read-only (10 tools), that task tools are conditionally present based on write scopes, and that CRUD tools are deprecated unless raw scope is set. This goes well beyond a bare listing statement and helps the agent set expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, with the main purpose front-loaded in the first sentence. The second sentence adds necessary behavioral context about scopes and deprecation, though its jargon ('Task tools register', 'raw scope') could be slightly clearer. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the zero-parameter design and presence of an output schema, the description covers the essential behavioral nuances: default read-only nature, conditional tool registration, and deprecation rules. It could be more explicit about the tool's purpose as a discovery mechanism, but it is largely complete for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to clarify about inputs. The description appropriately focuses on output composition rather than parameter details, which matches the baseline for parameter-free tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('curated Manager.io capabilities'), establishing this as a meta-tool for discovering available capabilities rather than a data record tool. It is distinguishable from siblings like list_records and the financial report tools, though 'curated' is somewhat vague about the exact selection criteria.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when an agent should call this tool versus alternatives like list_records or get_record. It mentions scope-related conditions for whether task or CRUD tools appear in the listing, but offers no direct guidance on when this tool is the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
profit_and_lossB
Profit and loss snapshot (read-only).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden; it explicitly states 'read-only', which conveys a non-mutating safety trait. It does not disclose how date parameters shape the report, whether a default period is applied, or what the returned data represents beyond the output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The entire description is six words and front-loads the key facts: the resource and its read-only nature. There is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, has an output schema, and the description plus parameter names convey a date-bounded P&L snapshot. Still, with no required parameters, an agent would not know what period is returned when both dates are omitted, and it lacks any indication of how this report relates to sibling financial reports.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention from_date or to_date at all. The parameter names are mildly self-explanatory, but the description adds no meaning about formats, boundaries, or default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies a clear resource ('profit and loss snapshot') and qualifies it as read-only, which makes the tool's purpose intelligible. However, it uses a noun phrase rather than a specific verb ('get', 'retrieve'), and does not distinguish it from sibling report tools like balance_sheet or trial_balance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool over alternatives such as balance_sheet, trial_balance, or tax_summary. The read-only label implies safety but does not establish selection criteria or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tax_summaryC
Tax summary snapshot (read-only).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden, and '(read-only)' is the only disclosure — it usefully signals no mutation but is thin. Nothing is said about what period is covered when from_date/to_date are null, how the snapshot is computed, or any prerequisites.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a four-word fragment with no wasted words and the read-only note is front-loaded. However, it errs toward under-specification rather than genuine efficiency, omitting the content needed to select and invoke the tool correctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although the tool is structurally simple (two optional date parameters, output schema present), the description is contextually incomplete: it sits among nine siblings including several financial summary tools, and nothing explains how tax_summary differs or what the date parameters govern. The name and the read-only parenthetical carry nearly all the weight.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the undocumented to_date and from_date parameters, but it mentions neither. The names are self-explanatory and the schema marks them optional with null defaults, yet the description supplies no date-format expectations, inclusivity semantics, or effective defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource ('tax summary') and output form ('snapshot'), making it reasonably clear this is a retrieval/report tool. It lacks an explicit verb, and given nine siblings including other financial reports, it does minimal differentiating work on its own, though the subject 'tax' sets it apart topically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use tax_summary versus sibling report tools such as profit_and_loss, balance_sheet, trial_balance, or bank_balances. An agent is left to infer the selection criteria from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
trial_balanceC
Trial balance snapshot (read-only).
| Name | Required | Description | Default |
|---|---|---|---|
| to_date | No | ||
| from_date | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full burden, and 'read-only' is a meaningful behavioral disclosure. However, it does not explain what happens when date parameters are omitted, what scope the snapshot covers, or how defaults are handled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with no filler or redundant content. The read-only qualifier is front-loaded, but the brevity comes at the cost of missing useful context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return-value details are covered elsewhere, but the description omits essential context about optional date parameters and how the trial balance snapshot is scoped. An agent cannot confidently call this tool correctly across all reasonable inputs based on the description alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no information about from_date or to_date. The agent is left entirely to the schema property names, which alone do not convey the intended date range semantics or defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource ('trial balance') and characterizes it as a read-only snapshot, which is enough to distinguish it from sibling reports like balance_sheet and profit_and_loss. It lacks a strong explicit verb like 'retrieves' or 'generates,' but the intent is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus sibling financial report tools. The description does not mention date-range behavior, nor does it exclude any alternatives, so an agent must infer appropriateness from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
10 tool updates
v0.2.6- First observed
aged_payables - First observed
aged_receivables - First observed
balance_sheet - First observed
bank_balances - First observed
get_record - First observed
list_records - First observed
list_resources - First observed
profit_and_loss - First observed
tax_summary - First observed
trial_balance
TDQS
Each tool addresses a clearly distinct purpose: record listing/retrieval, financial report snapshots, and a capability introspector. The descriptions explicitly disambiguate potentially similar tools like bank_balances versus bank_accounts and list_resources versus list_records.
The set mixes two naming conventions: list_/get_ for record operations and bare noun phrases for report snapshots like aged_payables and balance_sheet. Each group is internally consistent, but the overall set is not uniformly verb_noun.
Ten tools is well within the ideal range for a domain-specific MCP server. Every tool earns its place, covering record access plus a standard set of accounting/financial snapshots without redundancy.
The read-only surface is well covered: core collections can be listed/fetched, and standard accounting snapshots are available. Minor gaps remain, such as chart_of_accounts not being fetchable via get_record and no write/CRUD tools in the default read-only scope.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Open-source AI accounting skills verified by licensed accountants (tax, VAT, payroll).
QuickBooks Online in Claude and ChatGPT: 211 tools, full ledger, multi-company, Canada + US, FR/EN.
1Personal finance ledger for AI agents — query spending, track bills, forecast cash flow.
Connect your AI to your Well financial data - invoices, companies, contacts.
Related MCP Servers
- -licenseNot gradedqualityNot gradedmaintenanceEnables AI assistants to access and manage accounting data through the freee accounting API, supporting operations like transaction management, financial analysis, and account item management.2251-
- AlicenseAqualityDmaintenanceEnables AI assistants to query and manage QuickBooks Online data through natural language, including customers, invoices, bills, vendors, accounts, and financial reports.7MIT
- AlicenseNot gradedqualityBmaintenanceProvides AI assistants with direct access to HLedger accounting data and functionality, enabling natural language queries for balances, reports, journal entries, and financial analysis.4065MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to read and write Cynco accounting data, including querying books, creating invoices, reconciling transactions, and generating financial reports.151MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/onexurOSS/mcp-manager.io'
If you have feedback or need assistance with the MCP directory API, please join our Discord server