Sylex Search is a universal product/service discovery MCP server that lets AI agents search, evaluate, compare, and manage listings across 14,000+ products, services, and businesses.
Search & Discovery
search.discover — Search using natural language queries with optional filters (source, category, price, team size, rating, free tier); returns ranked results with fit scores
search.details — Retrieve full product data by ID, including pricing tiers, features, integrations, and review sentiment
search.compare — Side-by-side comparison of 2–5 products
search.categories — Browse all categories and subcategories with entry counts
search.alternatives — Find similar products scored by relevance
search.services — Discover agent infrastructure services (memory, auth, billing, logging, monitoring) with MCP connection configs
search.feedback — Report bad results, missing products, wrong data, or suggestions
Listing Management
manage.register — Add a new product or business to the index; returns an owner token
manage.claim — Claim or recover ownership of an existing listing via URL-based verification
manage.update — Update listing details (name, description, pricing, category, custom fields)
manage.list_mcp — Add or update MCP connection config so other agents can auto-discover and connect to your listing
Guided Workflows (Prompts)
search-workflow — Step-by-step guide: discover → details → compare → recommend
product-evaluation — Thorough evaluation flow: find product → get details → find alternatives → verdict
Search for and retrieve detailed information about Asana, including features, pricing, and alternatives for project management.
Search for Django and access details about its features, pricing, and alternatives for Python web frameworks.
Search for FastAPI and access details about its features, pricing, and alternatives for Python web frameworks.
Search for Flask and access details about its features, pricing, and alternatives for Python web frameworks.
Search for HubSpot and access details about its features, pricing, and alternatives for CRM solutions.
Search for Linear and access details about its features, pricing, and alternatives for project management.
Search for MobX and access details about its features, pricing, and alternatives for state management.
Search for Notion and access details about its features, pricing, and alternatives for project management.
Search for Redux and access details about its features, pricing, and alternatives for state management.
Search for Salesforce and access details about its features, pricing, and alternatives for CRM solutions.
Search for Sanic and access details about its features, pricing, and alternatives for Python web frameworks.
Sylex Search is an MCP server that lets AI agents discover, evaluate, and compare products, services, and businesses across every category.
Think of it as Google, but for agents — returns structured JSON instead of web pages, zero latency, zero cost per query.
Add to your MCP client config (Claude Desktop, Claude Code, Cursor, etc.):
{
"mcpServers": {
"sylex-search": {
"url": "https://search.sylex.ai/sse"
}
}
}smithery mcp add mastadoonprime/sylex-searchnpx sylex-searchRelated MCP server: disvr
McKinsey projects $1 trillion in sales will flow through AI agents. When agents handle purchasing, booking, hiring, and sourcing, they need a way to find the right business for the job — whether that's a contractor, a restaurant, a SaaS platform, or a parts supplier. If a business isn't in the index, it's invisible to agents.
Sylex Search is the discovery layer for agent commerce.
14,000+ entries and growing:
Source | Count | What |
npm | ~3,000 | JavaScript/TypeScript packages |
crates.io | ~3,000 | Rust crates |
Wikidata | ~2,800 | Products, companies, protocols |
MCP servers | ~2,100 | MCP tools from awesome-mcp-servers |
GitHub | ~1,900 | Popular repositories |
PyPI | ~1,000 | Python packages |
SaaS | ~100 | SaaS products |
The index started with software packages as seed data, but Sylex Search is not software-specific. The schema and tools support any product, service, or business.
Tool | Description |
| Search the index by natural language query. Returns ranked results with fit scores. |
| Get full product data by ID — pricing, features, integrations, reviews. |
| Side-by-side comparison of 2-5 products. |
| Browse all categories and subcategories with counts. |
| Find similar products scored by relevance. |
| Report issues or suggest improvements. |
Tool | Description |
| Add a new product or business to the index. Returns an owner token. |
| Verify ownership of an existing listing via URL proof. |
| Update listing details (description, pricing, category, etc.). |
| Add MCP connection config so other agents can discover and connect. |
Prompt | Description |
| Step-by-step guide: discover → details → compare → recommend. |
| Thorough evaluation: find product → get details → find alternatives → verdict. |
"react state management" → zustand, redux, mobx, jotai
"python web framework" → Django, Flask, FastAPI, Sanic
"project management tool for small teams" → Notion, Linear, Asana
"CRM with Slack integration" → HubSpot, Salesforce, Pipedrive
from langchain_mcp_adapters.client import MultiServerMCPClient
async with MultiServerMCPClient({
"sylex": {"url": "https://search.sylex.ai/sse", "transport": "sse"}
}) as client:
tools = client.get_tools()from agents import Agent
from agents.mcp import MCPServerSse
server = MCPServerSse(url="https://search.sylex.ai/sse")
agent = Agent(name="shopper", mcp_servers=[server])from autogen_ext.tools.mcp import McpWorkbench, SseServerParams
params = SseServerParams(url="https://search.sylex.ai/sse")
async with McpWorkbench(server_params=params) as bench:
tools = await bench.list_tools()from crewai import Agent
from crewai_tools import MCPTool
sylex_tools = MCPTool.from_sse(url="https://search.sylex.ai/sse")
agent = Agent(role="researcher", tools=sylex_tools)Zero LLM calls — deterministic search (SQLite FTS + custom ranking)
Millisecond responses — no API calls, no model inference
$0 per query — no token costs
Structured JSON — agents parse directly, no scraping needed
Agents-first — no dashboards, no accounts, no human UI
MCP native — built on the Model Context Protocol standard
Self-service — any business can register, claim, and manage its listing through tool calls
Property | Value |
Transport | SSE |
Quality score | 100/100 (Smithery) |
Version | 0.1.2 |
Tools | 11 |
Prompts | 2 |
Auth required | No |
Config required | No |
Server card available at:
GET https://search.sylex.ai/.well-known/mcp/server-card.jsonThis returns full server metadata including all tools, prompts, and connection details — no MCP session required.
pip install -r requirements.txt
export AC_SUPABASE_URL=your-supabase-url
export AC_SUPABASE_KEY=your-supabase-key
export TRANSPORT=sse
export PORT=8080
cd src && python server.pyAGPL-3.0 — see LICENSE for details.
Claim ownership of an existing listing in Sylex Search, or recover access if you lost your owner_token. Two-step process: (1) Call with just product_id to get a verification code and instructions. (2) Place the code at a URL you control, then call again with product_id + verification_url to complete the claim and receive your owner_token. Re-claiming rotates the token (old one dies).
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | Product ID to claim (from discover results) | |
| verification_url | No | URL where you placed the claim code. We'll fetch it and check for the code. Omit on first call to get the code and instructions. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains the two-step nature and the side effect of token rotation on re-claiming. It goes beyond the annotations (all false) by detailing the process. However, it could mention failure modes or permission requirements for full transparency.
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 three sentences long, front-loaded with purpose, and structured logically with step-by-step instructions. Every sentence provides essential information without redundancy.
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 lack of an output schema, the description hints at receiving an owner_token but does not detail the full response format. It also omits error handling or validation details. For a moderate-complexity tool, this is adequate but not 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?
With 100% schema description coverage, the baseline is 3. The description adds value by explaining that product_id comes from 'discover results' and that verification_url is omitted on first call. This enriches the schema's parameter definitions.
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 tool's purpose: claiming ownership of an existing listing or recovering access. It uses specific verbs ('claim', 'recover') and names a resource ('listing in Sylex Search'), distinguishing it from siblings like manage.register or manage.update.
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 outlines the two-step process and when to include each parameter. It provides clear instructions for first and second calls. However, it does not explicitly state when not to use the tool or compare it to alternatives, which would be beneficial.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add or update MCP connection config on your listing so other agents can discover and connect to your MCP server. Requires owner_token. This is how you make your product auto-discoverable by other agents.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | Product ID to add MCP config to | |
| owner_token | Yes | Owner token from register/claim | |
| mcp_config | Yes | MCP connection details. Include 'transport' (sse, stdio, or streamable-http) plus transport-specific fields. SSE: {"transport": "sse", "url": "https://your-server/sse"}. stdio: {"transport": "stdio", "command": "npx", "args": ["your-pkg"]}. streamable-http: {"transport": "streamable-http", "url": "https://your-server/mcp"}. You can also add 'tools' (list of tool names) and 'env' (required env vars). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true, readOnlyHint=false, and destructiveHint=false. The description adds minimal behavioral context beyond what annotations provide (e.g., it's a write operation, requires owner_token, and enables discoverability). No contradictions observed.
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 concise (three sentences) with no fluff. It could be better structured with clear separation of purpose and requirements, but it is adequately 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?
Given the tool's complexity (nested object, multiple transport types), the description is brief. It does not explain return values or error conditions, but the schema covers parameter details. Adequate but not thorough.
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 100% with detailed parameter descriptions. The description adds no extra meaning beyond summarizing the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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 tool's function: 'Add or update MCP connection config on your listing' for discoverability. It distinguishes itself from sibling tools (e.g., manage.register, manage.update) by focusing specifically on MCP configuration.
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 mentions the requirement for owner_token and the high-level purpose ('make your product auto-discoverable'). However, it does not explicitly state when not to use this tool or provide alternatives, but given no conflicting siblings, context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Register a new product, service, or business in Sylex Search. Returns an owner_token — store it! You need it to update your listing later. Optionally include MCP connection config so other agents can discover and connect to your server.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Product or business name | |
| description | Yes | What this product or business does (max 500 chars) | |
| url | Yes | Homepage or primary URL | |
| category | No | Category slug (use 'categories' tool to see options) | |
| subcategory | No | Subcategory slug (optional) | |
| mcp_config | No | MCP connection config so other agents can connect. For SSE: {"transport": "sse", "url": "https://..."}. For stdio: {"transport": "stdio", "command": "npx", "args": ["pkg"]}. For streamable-http: {"transport": "streamable-http", "url": "https://..."}. | |
| agent_services | No | Agent infrastructure services this product provides. Each entry: {"service_type": "memory|auth|billing|logging|monitoring", "mcp_config": {"transport": "sse", "url": "..."}, "capabilities": ["store", "retrieve", ...], "auth_method": "agent_token|oauth|none", "pricing": "free|freemium|paid", "description": "Short description"}. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are all false, so description carries the burden. It discloses that the tool creates a new listing, returns an owner_token to be saved, and optionally accepts MCP config for discoverability. No destructive side effects or contradictions with annotations.
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 wasted words. First sentence states the core action; second sentence adds critical guidance on token storage and optional config. 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?
Given the complexity (7 parameters including nested objects, no output schema), the description covers the essential return value (owner_token) and key usage. It could be slightly improved by explicitly noting that agent_services is optional, but the schema already handles that. Overall, it is sufficiently 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 coverage is 100% but description adds significant value: it highlights the required fields (name, description, url), explains the return of owner_token and its importance for updates, and provides concrete JSON examples for mcp_config config. This goes well beyond the schema's basic 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 clearly states 'Register a new product, service, or business in Sylex Search' with a specific verb and resource. It distinguishes from siblings like manage.update (update) and search.discover (search) by emphasizing creation and the unique owner_token return.
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 instructs to store the owner_token for later updates, implying this tool is for initial registration, not updates. It also mentions optional MCP config for future connectivity. However, it does not explicitly state when not to use it or name alternative tools for different actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update your listing in Sylex Search. Requires the owner_token you received from 'register' or 'claim'. Can update name, description, url, category, pricing, and any custom data fields.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | Product ID to update | |
| owner_token | Yes | Owner token from register/claim | |
| updates | Yes | Fields to update. Index fields: name, description, short_description, url, category, subcategory, price_model, has_free_tier. Use 'agent_services' to add/update infrastructure service declarations. Any other keys go into the data blob. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate it's not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds value by specifying the authentication requirement and the scope of updatable fields, enhancing transparency beyond annotations.
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 at two sentences, front-loaded with the core purpose, and every sentence adds necessary context without redundancy.
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 update tool with no output schema, the description sufficiently covers purpose, authentication, and updateable fields. It could mention partial vs full update behavior, but the word 'update' implies partial, so it's adequate.
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 input schema has 100% coverage, so the description's role is to add meaning. It does so by listing specific field types and clarifying the 'updates' object structure, including indexing and custom data handling, which goes beyond the schema 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 clearly identifies the action ('Update') and resource ('your listing in Sylex Search'). It distinguishes from siblings like 'register' and 'claim' by requiring the owner_token, making it unambiguous.
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 explicitly states the prerequisite of having an owner_token from 'register' or 'claim', guiding when to use this tool. However, it does not explicitly list alternative tools for other scenarios, though the sibling list provides context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find alternatives to a specific product. Returns similar products in the same category, scored by relevance (subcategory match, price similarity, ratings). Use after 'details' when exploring options.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | Product ID to find alternatives for | |
| max_results | No | Maximum alternatives to return (default 5, max 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover safety (readOnlyHint=true) and idempotency; the description adds scoring details that go beyond annotations without contradiction.
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 concise sentences with all essential information front-loaded, no unnecessary 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?
For a simple search tool with 2 parameters and no output schema, the description fully covers purpose, usage, and output structure.
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 100% with parameter descriptions; the description adds no additional meaning beyond the schema.
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 finds alternatives to a specific product and returns similar products in the same category with scoring criteria, distinguishing it from siblings like search.details and search.compare.
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?
Explicitly advises to use after 'details' when exploring options, providing clear usage context, though it doesn't explicitly state when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Browse all available product categories with counts and subcategories. Use this to understand what's in the index before searching, or to find the right category/subcategory slugs for filtered searches.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, non-destructive, idempotent behavior. The description adds value by detailing what the tool returns (counts and subcategories) and that it covers all available categories. No contradictions with annotations.
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 concise: two sentences, front-loaded with the action and resource. Every sentence contributes meaning without unnecessary 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?
Given zero parameters, rich annotations, and no output schema, the description adequately covers the tool's purpose, usage context, and return information (counts and subcategories). It is complete for the tool's simplicity, though it does not describe the exact return format.
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 input schema has zero parameters and is fully covered (100% coverage). The description does not need to add parameter information. Baseline score of 3 is appropriate.
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 ('browse') and the resource ('all available product categories'). It also specifies outputs ('counts and subcategories') and distinguishes itself from sibling search tools by noting its use case ('before searching' and 'find the right category/subcategory slugs').
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 instructs when to use this tool: 'to understand what's in the index before searching, or to find the right category/subcategory slugs for filtered searches.' It provides clear context without explicitly stating when not to use it, but the usage scenarios are well-defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compare 2-5 products side-by-side. Returns full data for each product so you can analyze pricing, features, and fit differences. Use after 'discover' when you have multiple candidates to evaluate. Each product's data may have a different shape — compare what's relevant to the decision.
| Name | Required | Description | Default |
|---|---|---|---|
| product_ids | Yes | List of product IDs to compare (2-5 products) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent. Description adds that returns full data and notes output shape may differ per product, which is valuable behavioral context beyond annotations.
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 sentences, each tightly packed: purpose, usage timing, and data variance note. No redundancy, front-loaded with core action.
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 1-param tool with no output schema, the description covers purpose, usage context, and output variability completely.
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 covers product_ids fully (100%). Description repeats '2-5 products' but adds no new parameter-level meaning; baseline 3 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 'Compare 2-5 products side-by-side' with a clear verb and resource, and distinguishes from siblings like 'search.details' by specifying the multi-product scope and purpose (analyze pricing, features, fit).
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?
Explicitly advises to 'Use after discover when you have multiple candidates to evaluate,' providing clear context. Does not list alternatives but implies when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full details for a specific product by ID. Returns complete data including pricing tiers, features, integrations, review sentiment, and alternatives. Use after 'discover' to deep-dive on a candidate. Data shape varies per product — each product describes itself differently.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | Product ID from discover results |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate idempotent and read-only behavior. The description adds value by noting 'Data shape varies per product' and listing return fields, which provides useful context beyond annotations.
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?
Four concise sentences with no redundancy. Key information is front-loaded (purpose, return data, usage context, behavioral note).
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 tool with one parameter, the description fully covers purpose, usage, return value variability, and ties to sibling tool discover. Lacks output schema but compensates with explicit listing of return fields.
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 100% for the single parameter. The description enhances meaning by explaining the parameter's source ('Product ID from discover results') and its role in the workflow.
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?
Clearly states 'Get full details for a specific product by ID' and lists returned data (pricing tiers, features, etc.). It also distinguishes from sibling 'search.discover' by specifying 'Use after discover'.
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 context by stating 'Use after discover to deep-dive on a candidate', but does not explicitly exclude other sibling tools or mention when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Sylex Search — search 11,000+ products, services, and businesses across every category. Returns ranked results with fit scores. Start here, then use 'details' or 'compare'. If results seem off, use 'feedback' to report it — we're actively improving.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Natural language search query, e.g. 'project management tool for small teams' or 'CRM with Slack integration' | |
| category | No | Filter by category slug. Use 'categories' tool to see available categories. Examples: project-management, crm, communication, design, development, analytics, marketing, hr, finance, security, ai-ml, deployment, customer-support | |
| subcategory | No | Filter by subcategory slug. Use 'categories' tool to see subcategories within a category. | |
| max_price | No | Maximum price per unit in USD | |
| min_rating | No | Minimum rating (0-5 scale) | |
| team_size | No | Your team size — filters to products that support this team size | |
| has_free_tier | No | Only show products with a free plan/tier | |
| source | No | Filter by data source: 'saas', 'npm', 'pypi', 'crates', 'github', 'wikidata'. Omit to search everything. | |
| max_results | No | Maximum results to return (default 5, max 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, destructiveHint, idempotentHint. Description adds that results are ranked with fit scores and that the tool is actively improved, which adds useful behavioral context beyond annotations.
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 sentences, all essential: first states purpose and scope, second gives usage flow to siblings, third encourages feedback. Perfectly front-loaded and no unnecessary 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 tool's complexity (9 params, all well-described in schema) and no output schema, the description covers purpose, result format (ranked with fit scores), usage flow, and scale. Sufficient for correct selection and 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 100%, so baseline is 3. Description does not add extra meaning to parameters; it only describes output. Adequate but no additional semantics.
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?
Clearly states verb 'search' and resource '11,000+ products, services, and businesses across every category'. Explicitly directs user to start here and then use sibling tools 'details' or 'compare', distinguishing from them.
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?
Explicitly tells agent to start with this tool and then use 'details' or 'compare' for further actions. Also advises to use 'feedback' if results are off, providing clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Report an issue or suggest an improvement for Sylex Search. We actively use feedback to improve search quality and coverage. Use this when: results are irrelevant, a product is missing, data is wrong, or you have a suggestion. Every report helps.
| Name | Required | Description | Default |
|---|---|---|---|
| feedback_type | Yes | Type of feedback | |
| query | No | The search query that produced bad results (if applicable) | |
| expected | No | What you expected to find | |
| actual | No | What you actually got (brief summary) | |
| message | Yes | Free-form feedback message with details |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=false and destructiveHint=false, which are consistent with a non-destructive write. The description adds motivation ('actively use feedback to improve') but no additional behavioral traits beyond what annotations imply.
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 two sentences: first states purpose, second lists use cases. It is concise, front-loaded, and every sentence adds 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 simple feedback submission tool with well-documented parameters, the description covers purpose, usage context, and motivation. No output schema is needed, and the description is complete enough.
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?
Input schema has 100% description coverage, so the schema already documents all parameters. The description does not add extra meaning beyond the schema, earning the baseline score of 3.
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 verb 'Report' and resource 'feedback for Sylex Search'. It distinguishes from sibling tools that are for searching or managing, making the purpose unambiguous.
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 lists scenarios when to use the tool (irrelevant results, missing product, wrong data, suggestion). It provides clear context but does not mention when not to use it or alternative tools, though none exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find agent infrastructure services by type — memory, auth, billing, logging, monitoring. Returns products that provide agent-facing services with MCP connection configs so you can connect directly. This is how agents discover infrastructure.
| Name | Required | Description | Default |
|---|---|---|---|
| service_type | Yes | Type of agent service to find: memory, auth, billing, logging, monitoring. Or 'all' to list everything. | |
| limit | No | Max results (default 10, max 25) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the description's behavioral disclosure is modest. It adds that the tool returns products with MCP connection configs, but lacks details about pagination, error conditions, or what happens if no services are found.
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 concise sentences, each adding value. Front-loaded with the core purpose, followed by output details and usage context. No unnecessary words 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?
Given the tool's simplicity (2 parameters, high schema coverage, clear annotations), the description covers purpose and behavior adequately. It lacks explicit mention of result format or pagination, but the context signals (no output schema, simple params) reduce the need for extensive detail.
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 100%, with both parameters already documented via descriptions. The description reiterates the service_type options (memory, auth, etc.) but does not add new semantic meaning beyond the schema, so baseline score of 3 is appropriate.
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?
Description clearly states the tool finds agent infrastructure services by type, listing specific examples (memory, auth, billing, logging, monitoring). It also explains the output includes MCP connection configs, distinguishing it from sibling search tools like search.discover or search.details.
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 implies usage context by stating 'This is how agents discover infrastructure.' It identifies when to use (finding agent services) but does not explicitly exclude scenarios or mention alternatives. Sibling tools exist (e.g., search.alternatives, search.compare) but no contrast is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
manage.claimmanage.list_mcpmanage.registermanage.updatesearch.alternativessearch.categoriessearch.comparesearch.detailssearch.discoversearch.feedbacksearch.servicesEach tool has a clearly distinct purpose: manage tools handle listing ownership and updates, while search tools cover discovery, details, comparison, alternatives, categorization, feedback, and specialized service search. No overlap in functionality.
All tools follow a consistent snake_case verb_noun pattern with clear prefixes (manage.* and search.*), making the tool set predictable and easy to navigate.
With 11 tools, the server is well-scoped for a search and listing management domain. Each tool serves a specific need without redundancy, and the count feels appropriate for the functionality offered.
The tool surface covers key operations: search, details, compare, alternatives, categories, feedback, and full listing management (register, claim, update, MCP config). The only minor gap is the lack of a delete/listing removal tool for owners.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Multi-engine search for AI agents. Trust scoring, local corpus, MCP-native. Self-hostable, BYOK.
Search engine for AI agents to find MCP servers, A2A agents, and skills on their own.
Agent-native search engine with live web research optimized for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/MastadoonPrime/sylex-search'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
