Oakferry Agents
Server Details
Search and compare Oakferry's apps with dated, sourced facts: platforms, prices, ratings, limits.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: search_products finds matches, get_product returns full facts on one item, compare_products produces comparison tables, and list_attributes enumerates filterable keys. Overlap between compare_products and get_product is minimal since the descriptions clarify table-vs-single-product scope.
All four tools follow a clean snake_case verb_noun pattern (compare_products, get_product, list_attributes, search_products). The convention is consistently applied with no style deviations.
Four tools is on the lean side but each covers a distinct step in product research (discover filters, search, inspect, compare). It fits the read-only scope without redundancy, though the set is slightly thin.
The surface covers the core research lifecycle: enumerate attributes, search with constraints, get details, and compare. A browse/list-all-products or category enumeration path is absent, but search without filters likely covers it as a workaround.
Available Tools
4 toolscompare_productsCompare productsARead-onlyIdempotentInspect
Comparison tables of products and their alternatives on shared attributes, each row sourced. Pass an id to get one table, or a product id to get every table it appears in, or nothing to list them.
| Name | Required | Description | Default |
|---|---|---|---|
| id | No | Comparison id | |
| product_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety and repeatability profile is fully covered elsewhere. The description adds one genuinely useful behavioral detail, that each row is sourced (provenance per row), but says nothing about table size, pagination or ordering.
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?
Two sentences, no filler. The output/what-it-is statement is front-loaded and the parameter routing follows immediately, with each clause doing distinct work.
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-optional-parameter, read-only lookup tool with no output schema, the description covers what is returned at a high level (tables, sourced rows) and all three call patterns. Only minor gaps remain, such as pagination or result ordering, which are unlikely to block 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 coverage is only 50% and product_id has no schema description at all, so the description must carry weight — and it does, explaining that product_id returns every table the product appears in and that omitting both params lists tables. It adds the inverse-lookup semantic that the bare schema cannot convey.
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 concrete resource and shape: comparison tables of products and their alternatives on shared attributes, with each row sourced. That clearly separates it from get_product, list_attributes and search_products without needing to open a schema, though it never names those siblings explicitly.
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 second sentence gives explicit selection logic across all three invocation modes (id for one table, product_id for every table containing that product, nothing to list), which is exactly the routing an agent needs. It stops short of stating when not to use this tool versus a sibling like search_products.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_productGet productARead-onlyIdempotentInspect
Full facts for one product: where to get it, every price, ratings with dates, features, attributes, when not to recommend it, third-party coverage and sources.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Product id from search_products |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive/non-openWorld, so the safety profile is covered. The description adds real behavioral value by disclosing the return content, notably 'when not to recommend it' and 'third-party coverage and sources', which tells the agent this is a decision-support payload, not just a record fetch. It doesn't cover absence/error behavior, keeping it from a 5.
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 front-loaded sentence that names the resource first and then enumerates contents; each item earns its place as a signal of what the payload contains. The colon-list is dense but not padded.
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?
With no output schema, the description must carry return-value meaning and it largely does by listing the data categories returned. Gaps remain around response format, sourcing of 'third-party coverage', and failure behavior for an unknown id.
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?
One parameter at 100% schema coverage, and the schema already documents 'Product id from search_products'. The description adds no parameter-level detail (id format, casing, validation) so the baseline 3 for fully-covered schemas applies.
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 verb+resource ('full facts for one product') and enumerates exactly what is covered: prices, ratings with dates, features, attributes, negative-recommendation signals, coverage and sources. The singular 'one product' implicitly contrasts with search_products/compare_products, but no sibling is named, 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 description never says when to use this versus list_attributes, search_products or compare_products, nor when not to use it. The only routing hint ('Product id from search_products') lives in the schema, not the description, leaving the agent to infer the search-then-fetch workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_attributesList attributesARead-onlyIdempotentInspect
Filterable attribute keys, the values products use for each, and how many products set it. Use these keys in search_products attributes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds the return contract: keys, the values used per key, and how many products set each. It does not note whether value lists are truncated or capped, which is the main remaining behavioral question for an inventory-style listing.
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?
Two sentences with no filler; the resource and its contents come first, and the cross-reference to search_products is placed last as actionable guidance.
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?
With no output schema and no parameters, the description carries the return-shape burden and does so reasonably, tying the output to its use in search_products. Minor gap: no mention of result size, pagination, or value-list truncation.
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?
Zero parameters, so the schema baseline is 4 and there is no parameter meaning for the description to add. No penalty for a parameterless discovery tool.
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 resource (filterable attribute keys) and enriches it with what comes back: each key's values and product counts. It is clearly distinct from siblings like get_product and compare_products, though it never states a verb explicitly.
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?
It gives a concrete downstream use: 'Use these keys in search_products attributes,' which tells the agent this is the discovery/feeder tool for filtering. No when-not or comparison against get_product/compare_products is offered, so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_productsSearch productsARead-onlyIdempotentInspect
Find products matching a person's constraints. Put hard requirements in the filters (platform, max_price, free, no_subscription, attributes) and the rest in query. Each result says why it matched. Call list_attributes to see filterable keys.
| Name | Required | Description | Default |
|---|---|---|---|
| free | No | Only products with a free offer | |
| limit | No | ||
| query | No | What the person wants, in their words | |
| category | No | ||
| platform | No | iOS, Android, Web, ... | |
| max_price | No | Most the cheapest way in may cost; 0 = free to start | |
| attributes | No | Exact attribute matches, e.g. {"offline": true} | |
| no_subscription | No | Only products usable without a subscription |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds useful return-format context ("Each result says why it matched"), which goes beyond what the annotations provide.
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?
Three tightly written sentences, front-loaded with the core purpose, followed by parameter-allocation guidance and a cross-reference. No filler; every sentence 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?
For an 8-parameter, nested-object, no-output-schema search tool, the description covers how to route inputs and vaguely what results contain. It could say more about the result payload (e.g., pagination or fields), but it is adequate 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 coverage is 75%, so the schema already documents most parameters. The description adds genuine semantic value by partitioning parameters into hard-requirement filters (platform, max_price, free, no_subscription, attributes) versus free-text query, guiding allocation between them beyond the schema text.
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 verb and resource ("Find products") with scope ("matching a person's constraints"). It distinguishes itself from list_attributes by routing there for filterable keys, but does not differentiate from compare_products or get_product, so it falls short of a full 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?
Gives clear operative guidance: put hard requirements in the filters and the rest in query, and call list_attributes to discover filterable keys. It lacks explicit when-not-to-use guidance relative to compare_products/get_product, so it stops short of 5.
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
- First observed
compare_products - First observed
get_product - First observed
list_attributes - First observed
search_products
Related MCP Connectors
Google Play & App Store app data: search, details, reviews, privacy, alternatives, top charts.
Neutral, sourced, dated facts for choosing software: price, free tier, idle rules, security record.
Neutral, sourced, dated facts for choosing software: price, free tier, idle rules, security record.
Research iOS and Android apps, use keyword marketing tools, see app installs, revenue and sdks.
Related MCP Servers
- AlicenseAqualityAmaintenanceMines public App Store and Steam reviews to surface the complaints, rating drops per version, and common pain points across one app or a set of competitors, with no API keys required. Enables natural-language comparison of up to eight apps or games by country and category so users can spot product opportunities and gaps.4MIT
- FlicenseCqualityDmaintenanceEnables querying and retrieving data from App Store and Google Play Store, including app details, reviews, ratings, rankings, permissions, and search capabilities across both iOS and Android platforms.20-
- AlicenseNot gradedqualityFmaintenanceQuery iOS App Store revenue and download estimates for any app directly from your agent. Two tools: estimate_app returns monthly revenue and downloads with a confidence label (verified / calibrated / modeled), and search_apps resolves an app name to its App Store id.67 npmMIT
- -licenseNot gradedqualityNot gradedmaintenanceEmpowers users to search and analyze mobile apps via the AppTweak API, providing insights into app store data, reviews, ratings, and keyword performance on iOS and Android platforms.-
Glama MCP Gateway
Add one secure layer between your agents and this server.