Tally MCP Server
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., "@Tally MCP Servershow me products under $5"
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.
mymarketaccount.net Tally MCP Server
Lightweight Node MCP server for querying Tally product/category data used by mymarketaccount.net.
It uses the same endpoints seen in the web app:
GET /cartapi/cart/categoriesGET /cartapi/cart/products
and sends Authorization: Bearer <token>.
Prerequisites
Node.js 18+
A valid Tally bearer token (not the gateway/Auth0 token)
Your
locationIdandaccountId
Related MCP server: easypaydirect-mcp
Install
npm installRun
npm startOptional environment variables
TALLY_TOKENdefault bearer tokenTALLY_LOCATION_IDdefault4dfd336941716947dba20acffc45660dTALLY_ACCOUNT_IDdefault accountTALLY_PAGE_SIZEdefault page size for product paging (default100)TALLY_BASE_URLdefaulthttps://tally.prod.readytouchpos.comTALLY_API_KEYdefault3C9DEDE2-EC3E-43E3-9C20-E591ED341127
MCP tools
set_tally_token(token)list_categories(locationId?, token?)list_products(locationId?, accountId?, token?, category?, search?, minPrice?, maxPrice?, sortBy?, limit?, pageSize?, maxPages?, maxRecords?)ask_products(question, locationId?, accountId?, token?, category?, search?, minPrice?, maxPrice?, sortBy?, limit?, pageSize?, maxPages?, maxRecords?)
ask_products supports lightweight question inference for phrases like:
under $3over 5between 2 and 4top 10cheapest,best deal,average,how many
Example MCP client config
{
"mcpServers": {
"tally": {
"command": "node",
"args": ["/home/kurtk/mtb-hq-snack-kiosk-mcp/src/index.js"],
"env": {
"TALLY_LOCATION_ID": "4dfd336941716947dba20acffc45660d",
"TALLY_ACCOUNT_ID": "<account-id>"
}
}
}
}[mcp_servers.tally]
command = "node"
args = ["<path to repo>/src/index.js"]
[mcpServers.tally.env]
TALLY_LOCATION_ID = "4dfd336941716947dba20acffc45660d"
TALLY_ACCOUNT_ID = "<account-id>"Then call:
set_tally_tokenwith your current token.ask_productsorlist_productsfor product/price questions.
Notes
Token minting (
/tallyapi/auth/registerand/tallyapi/auth/login) is intentionally not implemented here; this server expects an already valid token.Token set via
set_tally_tokenis held in process memory for the running MCP session.
Available Tools
4 toolsask_productsC
Answer natural-language questions about products/prices by querying Tally data.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| token | No | ||
| search | No | ||
| sortBy | No | ||
| category | No | ||
| maxPages | No | ||
| maxPrice | No | ||
| minPrice | No | ||
| pageSize | No | ||
| question | Yes | ||
| accountId | No | ||
| locationId | No | ||
| maxRecords | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It only states that the tool queries Tally data to answer questions; it omits behavioral details such as whether the tool performs reads only, how it handles pagination or limits, whether authentication is required, and what the response format looks like.
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 single sentence is grammatically tight and has no filler, but it is underspecified for a tool with 13 parameters. The one sentence does not earn its place by conveying enough information; it reads as a terse summary rather than a complete tool definition.
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 tool with 13 undocumented parameters, no output schema, and no annotations, the description is far too minimal. It does not explain how the natural-language question is interpreted, what filtering parameters do, what the response contains, or how it relates to the sibling list and token tools.
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 there are 13 parameters, including meaningful filters like limit, minPrice, maxPrice, sortBy, and category. The description provides no parameter-level meaning and does not compensate for the schema's lack of descriptions.
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 uses a specific verb ('Answer') and a clear resource ('natural-language questions about products/prices'), and identifies the data source ('Tally data'). However, it does not explicitly differentiate this from siblings such as list_products, so it stops short of a 5.
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 phrase 'natural-language questions' implies when the tool should be used, but the description gives no explicit guidance about when to prefer it over list_products, list_categories, or set_tally_token, and no exclusions or prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesC
List product categories available for a location.
| Name | Required | Description | Default |
|---|---|---|---|
| token | No | ||
| locationId | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, and it only conveys that the operation lists data (read-only by implication). It says nothing about authentication via token, whether locationId is required, error behavior, or how results are returned.
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 definition is a single front-loaded sentence with no filler; the verb comes first and every word contributes meaning. It is efficient, though the brevity comes at the cost of omitted parameter 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?
For a tool with two undocumented parameters, no annotations, and no output schema, the description covers only the basic action. Missing context includes the token's role, how locationId selects the location, and what the list response looks like, so an agent must guess at the invocation contract.
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 coverage is 0%, so the description must explain both parameters; it does not. 'Available for a location' loosely maps to locationId, but token is entirely unexplained and neither parameter's format, optionality, or purpose is clarified.
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 a specific verb ('List'), a concrete resource ('product categories'), and a scoping qualifier ('available for a location'). It is clear enough that an agent can tell it apart from sibling list_products by resource type, though it never explicitly contrasts itself with any 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?
The description provides no guidance on when to call this tool versus set_tally_token, list_products, or ask_products, and no prerequisites are stated. The only implicit signal is that a location scopes the result, which is too thin to route an agent reliably.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_productsC
Retrieve products with optional category/search/price filters.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| token | No | ||
| search | No | ||
| sortBy | No | ||
| category | No | ||
| maxPages | No | ||
| maxPrice | No | ||
| minPrice | No | ||
| pageSize | No | ||
| accountId | No | ||
| locationId | No | ||
| maxRecords | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It indicates a read-style retrieval, but omits important behaviors such as pagination via token, maxPages/pageSize handling, sorting, and what the response contains.
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 efficient sentence with no filler. It front-loads the core purpose and filter types, though it could have used the available space to add more value.
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 12-parameter tool with no annotations and no output schema, this description is incomplete. It does not explain pagination, sorting, token usage, or response shape, leaving an agent under-informed for correct 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%, so the description must compensate for 12 parameters. It only clarifies category, search, and price filters, leaving limit, token, sortBy, maxPages, pageSize, and other parameters semantically unexplained.
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 (retrieve), the resource (products), and the available filter dimensions (category, search, price). This is specific enough to distinguish it from list_categories, though it does not explicitly contrast with ask_products.
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 offers no guidance on when to prefer this tool over alternatives like ask_products or list_categories. It implies this is the tool for straightforward product listing, but does not state exclusions or conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
set_tally_tokenA
Set or update the Tally bearer token used by other tools.
| Name | Required | Description | Default |
|---|---|---|---|
| token | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It correctly implies a stateful mutation by saying 'Set or update' and notes the downstream effect on other tools. However, it does not disclose whether the token persists, whether it is validated, or how it affects subsequent calls beyond being 'used.'
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?
A single, focused sentence states the action, the resource, and the purpose without wasted words. The essential information is front-loaded.
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 simple one-parameter setter with no output schema or annotations, the description is nearly complete. It identifies the parameter's purpose and the relationship to sibling tools. A small gap is the lack of an explicit statement that this must be called before using the Tally-related tools.
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 schema only defines 'token' as a non-empty string, and description coverage is 0%. The description adds that it is a Tally bearer token used by other tools, which adds real meaning. However, it does not clarify the expected token format (e.g., raw token vs 'Bearer <token>'), so it only partially compensates for the missing schema description.
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 uses a specific verb ('Set or update') with a specific resource ('the Tally bearer token') and states its purpose ('used by other tools'). This clearly differentiates it from sibling data-retrieval tools like list_categories and list_products.
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 phrase 'used by other tools' gives clear context that this is a prerequisite/setup step for the sibling tools, without explicitly stating 'call this before using the other tools.' No exclusion criteria or alternatives are needed, so this is clear context rather than fully explicit when-to-use guidance.
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.
4 tool updates
v0.1.0- First observed
ask_products - First observed
list_categories - First observed
list_products - First observed
set_tally_token
TDQS
Scored across 4 tools
set_tally_token and list_categories are clearly distinct from the other tools. list_products and ask_products both retrieve product data, so they could be confused, but their descriptions separate structured filtering from natural-language querying.
Most tool names follow a clear verb_noun snake_case pattern: set_tally_token, list_categories, list_products. ask_products deviates slightly from the action style but remains readable and consistent with the overall convention.
Four tools form a compact, focused server for exploring and querying product/category data. The count is small but appropriate for a read-oriented Tally integration, and each tool has a clear role.
The set covers authentication, category listing, product listing/filtering, and natural-language product questions, which covers the core query workflow. Some gaps exist, such as no explicit product detail-by-ID or location-listing tool, but agents can likely work around these.
Maintenance
Related MCP Connectors
Hosted MCP server for Mini Accountant: invoices, expenses, customers, analytics, tax estimates.
Query your real net worth, spending, transactions, budgets and portfolio from any MCP client.
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
MCP server for querying Forkast documentation
Related MCP Servers
- AlicenseAqualityAmaintenanceA local MCP server for grocery shopping, enabling product search, specials, and browsing across NZ supermarkets, with cart and order history for Countdown/Woolworths via browser-assisted login.141MIT
- AlicenseAqualityAmaintenanceRead-only MCP server for Easy Pay Direct / NMI payment gateway, enabling natural language queries of transactions, subscriptions, and customer vault records.7245 npmMIT
- AlicenseNot gradedqualityCmaintenanceA lightweight, local inventory-intelligence MCP server that enables querying structured inventory schemas with read-only, zero-config tools for stock levels, velocity metrics, and purchase orders.6 npmMIT
- AlicenseNot gradedqualityCmaintenanceA read-only MCP server for Wave Accounting that lets you query accounts receivable (outstanding invoices with viewing status) and monthly invoiced revenue via natural language.MIT