Woolworths MCP Server

by elijah-g

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose with no ambiguity. Each tool targets a specific action on a specific resource (e.g., cart operations, product search, browser management), and the descriptions reinforce these distinctions. There is no overlap that would cause misselection.
Naming Consistency5/5
All tools follow a consistent 'woolworths_verb_noun' pattern throughout, using snake_case and starting with the server name prefix. This predictable naming scheme makes it easy to identify and understand each tool's function at a glance.
Tool Count5/5
With 12 tools, the count is well-scoped for an e-commerce shopping assistant server. Each tool earns its place by covering essential operations like browsing, searching, cart management, and session handling, without being excessive or too sparse.
Completeness5/5
The tool surface provides complete CRUD/lifecycle coverage for the Woolworths shopping domain. It includes session setup (open/close browser, get cookies), product discovery (categories, search, specials, details), and full cart management (add, remove, update, get), with no obvious gaps that would hinder agent workflows.
Average 3.2/5 across 12 of 12 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under GPL 3.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but fails to mention critical details such as whether this requires authentication, if it modifies server-side state, potential error conditions (e.g., invalid stockcode), or side effects. This leaves the agent with insufficient information to predict tool behavior safely.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence that efficiently conveys the core functionality without unnecessary words. It is front-loaded with the essential action, making it easy for an agent to parse quickly. Every word earns its place, achieving optimal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for a mutation tool. It does not cover behavioral aspects like authentication needs, error handling, or response format, which are crucial for an agent to use the tool effectively. The high schema coverage mitigates some gaps but not enough for a complex operation like adding to a cart.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear documentation for both parameters (stockcode and quantity). The description adds no additional semantic context beyond what the schema provides, such as examples of valid stockcodes or constraints on quantity. This meets the baseline for adequate parameter documentation but does not enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add') and the target ('product to the shopping cart/trolley'), making the purpose immediately understandable. However, it does not differentiate this tool from its sibling 'woolworths_update_cart_quantity', which could also modify cart contents, leaving room for ambiguity in tool selection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'woolworths_update_cart_quantity' or 'woolworths_remove_from_cart'. It lacks context about prerequisites (e.g., needing an active session) or typical workflows, leaving the agent to infer usage 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.
Behavior2/5
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 states it 'Get[s] detailed information', implying a read-only operation, but doesn't clarify aspects like whether it requires authentication, rate limits, error handling, or what format the information is returned in. For a tool with no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded with the core action and resource, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a read operation with one parameter) and the absence of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed information' entails, how results are structured, or any behavioral traits like error cases. For a tool with no structured output, more descriptive context is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'stockcode' documented as 'The product stockcode/ID'. The description adds no additional semantic context beyond this, such as examples or format details. According to the rules, with high schema coverage (>80%), the baseline score is 3, which is appropriate here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a specific product', making the purpose explicit. It distinguishes from siblings like 'woolworths_search_products' by focusing on a single product via stockcode rather than searching. However, it doesn't specify what 'detailed information' includes, which slightly limits differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use it over 'woolworths_search_products' or other siblings, nor does it specify prerequisites like requiring a stockcode from another operation. This leaves usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe how it behaves—such as whether it requires authentication, has rate limits, returns real-time or cached data, or what format the results come in. This leaves significant gaps for an agent to understand the tool's operational characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence that efficiently conveys the core purpose without any unnecessary words. It's front-loaded with the essential information, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for a tool that retrieves data. It doesn't explain what the return values look like (e.g., list of products with prices), potential limitations (e.g., pagination, availability), or how it integrates with other tools like cart operations. This leaves the agent with insufficient context to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting both optional parameters ('category' and 'pageSize') with their purposes and defaults. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline for adequate but not exceptional coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('current specials and deals from Woolworths'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'woolworths_search_products' or 'woolworths_get_categories', which could also retrieve product-related information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention whether this is for browsing deals versus searching for specific products, nor does it reference sibling tools like 'woolworths_search_products' for more targeted queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal insight. It states the action but doesn't describe what 'navigate' entails (e.g., page loading, potential errors, session persistence, or interaction with other tools). For a navigation tool in a web automation context, this lack of detail on behavior is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence that efficiently conveys the core action without unnecessary words. It is front-loaded with the key verb and resource, making it easy to parse quickly, which is ideal for conciseness in a tool definition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of web navigation (which can involve errors, loading states, or session dependencies) and the absence of both annotations and an output schema, the description is incomplete. It doesn't address what happens after navigation (e.g., success indicators, returned page content, or error handling), leaving critical context gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'url' parameter clearly documented. The description adds no additional meaning beyond what the schema provides (e.g., no constraints on URL format or domain specificity). According to the rules, with high schema coverage, the baseline is 3 even without param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Navigate to') and target resource ('a specific URL on the Woolworths website'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'woolworths_open_browser' or 'woolworths_get_categories' that might involve navigation implicitly, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the browser must be open first using 'woolworths_open_browser'), nor does it clarify use cases like navigating to product pages versus category pages, leaving the agent to infer context from sibling tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the action but doesn't cover important aspects like whether removal is permanent, if it requires authentication, what happens on success/failure, or any rate limits. This is particularly problematic for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently communicates the core function without unnecessary words. It's appropriately sized for a simple tool with one parameter and gets straight to the point with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after removal (e.g., success confirmation, error cases, or what the cart state becomes). Given the complexity of modifying shopping cart state and the lack of structured safety information, more behavioral context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description doesn't add any parameter information beyond what's already in the schema (which has 100% coverage). The schema clearly documents the single 'stockcode' parameter as 'The product stockcode/ID to remove.' Since schema coverage is complete, the baseline score of 3 is appropriate - the description doesn't compensate but doesn't need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Remove') and target ('a product from the shopping cart/trolley'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'woolworths_update_cart_quantity' which could also modify cart contents, leaving room for potential confusion about when to choose one over the other.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this is for complete removal versus quantity adjustment (which 'woolworths_update_cart_quantity' might handle) or mention prerequisites like having items in the cart. The description only states what it does, not when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool updates quantity but doesn't mention critical aspects like whether this requires authentication, if it's idempotent, what happens with invalid stockcodes or quantities, or if there are rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without any fluff. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, achieving optimal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool modifies cart state (a mutation) with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral traits like side effects, error handling, or response format, which are crucial for safe invocation. For a 2-parameter mutation tool in a sibling-rich context, this leaves too many unknowns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with clear parameter definitions ('stockcode' as product ID, 'quantity' as new quantity). The description adds no additional semantic context beyond what's in the schema (e.g., it doesn't explain format constraints or valid ranges). This meets the baseline for high schema coverage but doesn't enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update the quantity') and target resource ('of a product in the shopping cart/trolley'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'woolworths_add_to_cart' or 'woolworths_remove_from_cart', which also modify cart contents, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't specify if this is for existing items only (vs. 'woolworths_add_to_cart' for new items) or clarify edge cases like setting quantity to zero (which might overlap with 'woolworths_remove_from_cart'). This lack of context leaves the agent to infer usage from tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action ('Get') but doesn't disclose behavioral traits such as whether this requires authentication, if it's a read-only operation, what format the cart contents are returned in, or if there are any rate limits. The description is minimal and lacks essential context for safe and effective use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded and efficiently communicates the core function, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of cart operations in e-commerce and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return value includes (e.g., items, quantities, prices) or any dependencies like needing an active session. For a tool that likely interacts with user data, more context is needed for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately doesn't mention any. This meets the baseline for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('contents of the shopping cart/trolley'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'woolworths_update_cart_quantity' or 'woolworths_remove_from_cart', which also involve cart operations but with different actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't clarify if this should be used to check cart contents before modifying it with 'woolworths_add_to_cart' or 'woolworths_remove_from_cart', or if it's for monitoring changes. There's no mention of prerequisites like requiring an open browser session.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't reveal any behavioral traits—such as whether it's a read-only operation, requires authentication, has rate limits, or returns structured data. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently conveys the core function without any wasted words. It's front-loaded with the essential action and resource, making it easy for an agent to parse quickly. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what the return value looks like (e.g., a list of category names, IDs, or nested structures), nor does it address potential errors or dependencies. For a tool with no structured metadata, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics, as there are none to explain. It appropriately focuses on the tool's purpose without unnecessary detail, meeting the baseline for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('list of available product categories'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'woolworths_get_specials' or 'woolworths_get_product_details', which might also retrieve category-related information in different contexts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether a browser session must be open), nor does it compare to siblings like 'woolworths_search_products' or 'woolworths_get_specials' that might involve categories. This leaves the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. 'Closes the browser instance' implies a destructive action that terminates a session, but it doesn't specify what happens to any open pages, cookies, or state. It also doesn't mention whether this requires an existing browser instance to be open or what happens if called multiple times.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's perfectly front-loaded with the essential information and doesn't contain any unnecessary elaboration. This is an excellent example of conciseness for a simple operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description adequately states what the tool does. However, as a potentially destructive operation with no annotations, it should ideally mention behavioral implications like what gets cleaned up or whether this affects other tools. The completeness is minimal but sufficient for the basic operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema description coverage is 100%, so there are no parameters to document. The description appropriately doesn't mention parameters since none exist, which is correct for this case. A baseline of 4 is appropriate for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Closes') and the resource ('the browser instance'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools, but given the tool name 'close_browser' and sibling 'open_browser', the distinction is somewhat implied through naming conventions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives or what context it should be used in. While it might be obvious from the name that this is for closing a browser after other operations, there's no explicit mention of prerequisites, sequencing, or relationship to sibling tools like 'open_browser'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the requirement for session cookies, which is useful context about authentication needs. However, it doesn't describe other behavioral traits such as whether this is a read-only operation, potential rate limits, error handling, or the format of search results. For a search tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose followed by a prerequisite. Every sentence earns its place by providing essential information without waste. It is appropriately sized and structured for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a search tool with 5 parameters), no annotations, and no output schema, the description is incomplete. It covers the purpose and a key prerequisite but lacks details on behavioral traits, result format, or error handling. The schema handles parameters well, but without annotations or output schema, the description should do more to compensate, making it only adequate with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are documented in the input schema with descriptions and defaults. The description adds no additional parameter semantics beyond what the schema provides. According to the rules, with high schema coverage (>80%), the baseline score is 3 even with no param info in the description, which applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search for products') and the resource ('on Woolworths'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from sibling tools like 'woolworths_get_product_details' or 'woolworths_get_specials', which might also retrieve product information. The purpose is clear but lacks sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context for usage with 'Requires session cookies to be obtained first', indicating a prerequisite. This helps the agent understand when to use this tool (after authentication). However, it doesn't specify when to use this tool versus alternatives like 'woolworths_get_specials' for special offers or 'woolworths_get_product_details' for detailed product info, so it lacks full alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions retrieving cookies from 'the current browser session,' implying it's read-only and session-dependent, which adds useful behavioral context. However, it lacks details on permissions, data format, or potential errors, leaving gaps for a tool that accesses sensitive session data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by usage timing. Every word earns its place with no redundancy or fluff, making it efficient and easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose and usage but lacks details on return values, error handling, or security implications. For a tool that retrieves session cookies—a sensitive operation—more context on output format or limitations would improve completeness, though the concise description is adequate for minimal functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add param info, which is appropriate. A baseline of 4 is applied as per rules for zero parameters, since the tool's purpose is clear without parameter elaboration.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with 'Retrieves session cookies from the current browser session,' specifying both the action (retrieves) and resource (session cookies). It distinguishes from siblings by focusing on session data rather than browsing, cart operations, or product queries. However, it doesn't explicitly contrast with tools like woolworths_close_browser that might also involve session handling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use it: 'Run this after logging in or establishing a session.' This gives practical timing guidance. It doesn't specify when not to use it or name alternatives, but the context implies it's for post-authentication scenarios, which is helpful for agent decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions establishing a session, which implies this tool may create browser state or cookies needed for subsequent operations. However, it doesn't disclose behavioral traits like whether it requires authentication, potential side effects (e.g., opening visible browser windows), or error handling. The description adds some context but lacks depth for a tool with session implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences that are front-loaded with the core action and followed by usage context. Every word earns its place: the first sentence states what it does, the second explains why/when to use it. No redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter, no output schema, no annotations), the description is reasonably complete. It covers purpose and usage guidelines well. However, for a session-establishing tool, it could benefit from more behavioral details (e.g., what 'establish a session' entails, error cases). The absence of output schema isn't critical here as the action is straightforward.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents the single parameter 'headless'. The description doesn't add any parameter-specific information beyond what's in the schema, but with 0 required parameters and high schema coverage, the baseline is 3. It gets a 4 because the description implicitly supports the parameter's purpose by mentioning 'easier login' in the context of session establishment, though this is not explicit in the description text itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Opens a browser and navigates to Woolworths website') and distinguishes it from siblings by emphasizing it's 'the first step to establish a session', unlike tools like woolworths_navigate which presumably navigates within an existing session. It uses precise verbs and identifies the target resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'This is the first step to establish a session.' This provides clear context for usage relative to other tools like woolworths_close_browser (for ending sessions) or woolworths_navigate (for subsequent navigation). It effectively guides the agent on sequencing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![Woolworths-mcp MCP server](https://glama.ai/mcp/servers/elijah-g/Woolworths-mcp/badges/card.svg)](https://glama.ai/mcp/servers/elijah-g/Woolworths-mcp)

Score Badge

Copy to your README.md:

[![Woolworths-mcp MCP server](https://glama.ai/mcp/servers/elijah-g/Woolworths-mcp/badges/score.svg)](https://glama.ai/mcp/servers/elijah-g/Woolworths-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/elijah-g/Woolworths-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server