Italian B2B Lead List Scoring, Ranking & JSON Decisions
Server Details
Prioritize an existing Italian B2B lead list into up to 250 explained JSON decisions.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.1/5 across 6 of 6 tools scored.
Each tool targets a distinct function: buyer fit check, catalog retrieval, purchase requirements, synthetic example, business need mapping, and order intent preparation. No two tools have overlapping purposes, making it clear to an agent which tool to use for each task.
All six tools follow a consistent verb_noun snake_case pattern (e.g., check_buyer_fit, get_product_catalog). The naming is uniform and predictable, aiding agent selection.
With 6 tools, the count is reasonable for a focused server. However, the server name 'B2B Lead Scoring' suggests tools for scoring leads, but the actual tools are more about product catalog and order preparation, creating a slight mismatch in perceived scope.
For a lead scoring server, critical tools such as score_lead, get_lead_score, or lead_ranking are missing. The existing tools cover pre-sales steps but not the core scoring functionality, leaving significant gaps for the stated purpose.
Available Tools
6 toolscheck_buyer_fitCheck MachineSignal buyer fitARead-onlyIdempotentInspect
Check whether an Italian B2B buyer with an existing company, domain, CRM or lead list can use MS-DEC-250 to score, rank and prioritize up to 250 records. Coarse non-personal facts only; it creates no order.
| Name | Required | Description | Default |
|---|---|---|---|
| country | Yes | Two-letter country code, for example IT. | |
| primary_need | No | Optional non-personal demand category used only in ephemeral aggregate counters; never send free text or buyer data. | |
| customer_type | Yes | Buyer type. MachineSignal accepts B2B only. | |
| requested_product_code | No | Product being considered. Defaults to the entry product MS-DEC-250. | |
| has_existing_company_list | Yes | Whether the buyer already has a company, domain, CRM or lead list to evaluate. |
Output Schema
| Name | Required | Description |
|---|---|---|
| reason | Yes | |
| eligible | Yes | |
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
| fit_status | Yes | |
| reason_code | Yes | |
| next_resource | No | |
| ready_to_prepare | Yes | |
| checkout_url_returned | No | |
| recommended_next_tool | No | |
| requested_product_code | Yes | |
| recommended_next_arguments | No | |
| next_step_after_preparation | No | |
| buyer_data_must_remain_local | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that the check uses coarse non-personal facts only and creates no order, which aligns with and supplements the annotations. It doesn't contradict any annotation.
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?
Single sentence that is front-loaded with the core action and scope. Every word contributes value: verb, target audience, constraints, and outcome. No unnecessary elaboration.
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 output schema exists, the description need not detail return values. It covers the main check purpose and constraints. For a simple eligibility check with 5 parameters and clear annotations, the description 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 description coverage is 100%, so the baseline is 3. The description does not add parameter-specific meaning beyond what the schema already provides. The overall purpose context is helpful, but no param details are enriched.
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 checks if an Italian B2B buyer with existing company data can use MS-DEC-250 for scoring/ranking/prioritizing records. It uses a specific verb ('check') and resource ('buyer fit'), distinguishing it from siblings like get_product_catalog or prepare_order_intent.
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 when to use: when determining if a buyer can use the product. It doesn't explicitly state when not to use or name alternatives, but sibling tool names provide enough context for differentiation. A clear context is provided, though exclusions are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_product_catalogGet MachineSignal product catalogARead-onlyIdempotentInspect
Find an API product to score, classify, rank and prioritize an existing Italian B2B company or lead list into up to 250 explained JSON decisions. Returns the canonical catalog and permanent safety boundaries; read-only and no buyer data.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| service | Yes | |
| version | Yes | |
| products | Yes | |
| resources | Yes | Canonical public MachineSignal resources. |
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and openWorldHint. The description adds context: 'Returns the canonical catalog and permanent safety boundaries; read-only and no buyer data.' This confirms the read-only nature and clarifies that no buyer data is involved, adding value beyond the 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. The first sentence front-loads the core function, and the second provides return and behavioral details. Every sentence adds value 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 tool has no parameters, rich annotations, and an output schema, the description is complete. It explains the purpose, return value (catalog and safety boundaries), and behavioral traits. No additional information is needed for an agent to invoke it correctly.
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 no parameters, so baseline is 4. The description does not need to add parameter meaning since there are none. It correctly focuses on the tool's purpose and output.
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: to find an API product that scores, classifies, ranks, and prioritizes Italian B2B companies into up to 250 JSON decisions. The verb 'find' and resource 'product catalog' are specific, and the scope distinguishes it from sibling tools like check_buyer_fit or get_purchase_requirements.
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 when needing to score, classify, rank, or prioritize Italian B2B companies, but it does not explicitly state when to use this tool versus siblings or provide exclusions. There is no direct guidance on alternatives, leaving some ambiguity for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_purchase_requirementsGet controlled purchase requirementsARead-onlyIdempotentInspect
Explain the machine-origin purchase prerequisites without accepting an order, returning checkout data or calling a provider.
| Name | Required | Description | Default |
|---|---|---|---|
| product_code | Yes | Product whose controlled machine-origin purchase requirements should be returned. |
Output Schema
| Name | Required | Description |
|---|---|---|
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
| order_policy | Yes | |
| product_code | Yes | |
| customer_scope | Yes | |
| legal_resources | Yes | |
| ready_to_prepare | Yes | |
| input_requirement | Yes | |
| machine_onboarding | Yes | |
| checkout_url_returned | Yes | |
| recommended_next_tool | No | |
| mcp_order_tool_exposed | Yes | |
| recommended_next_arguments | No | |
| next_step_after_preparation | No | |
| authoritative_order_protocol | Yes | |
| buyer_data_must_remain_local | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds that it does not call a provider or return checkout data, reinforcing the safe, explanatory nature. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence that efficiently conveys purpose and constraints. Every part is meaningful, though slight wordiness ('without accepting...') could be tightened.
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 a simple parameter, comprehensive annotations, and an output schema present, the description adequately covers the tool's behavior. No major gaps are evident.
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 the single product_code parameter fully described via enum and description. The tool description adds no new parameter information beyond this, so baseline score of 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?
The description clearly states the tool explains machine-origin purchase prerequisites with a specific verb and resource. It distinguishes itself from siblings like check_buyer_fit and prepare_order_intent by focusing on requirements without order processing, but does not explicitly name alternatives.
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 the tool is for informational purposes by noting it does not accept orders or return checkout data. It lacks explicit guidance on when to use this tool versus siblings like get_product_catalog or map_business_need.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_synthetic_exampleGet a synthetic MachineSignal output exampleARead-onlyIdempotentInspect
Preview the JSON produced when MachineSignal scores, classifies, ranks and prioritizes an Italian B2B lead list. Uses approved synthetic data only and creates no order.
| Name | Required | Description | Default |
|---|---|---|---|
| product_code | Yes | Product whose approved synthetic output preview should be returned. |
Output Schema
| Name | Required | Description |
|---|---|---|
| example | Yes | Approved synthetic product preview; never real buyer or company data. |
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
| canonical_example_url | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context about using synthetic data only and creating no order, which aligns with and reinforces the 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 with two sentences that front-load the purpose and key constraints. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return values are covered. The description provides adequate context for a preview tool, though it lacks details on potential errors or response size.
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 enum and description for the single parameter. The description does not add further parameter details, so it meets the baseline but does not exceed it.
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 provides a preview of JSON output for a specific product code, using a specific verb ('Preview') and resource ('JSON produced when MachineSignal scores...'). It distinguishes from sibling tools like check_buyer_fit or prepare_order_intent by focusing on previewing output rather than performing actions.
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 'uses approved synthetic data only and creates no order,' implying it is safe and non-destructive, but does not explicitly state when to use this tool versus alternatives like get_product_catalog or check_buyer_fit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
map_business_needMap a general B2B business need for product researchARead-onlyIdempotentInspect
Map any structured B2B business need from Italy or a foreign market for aggregate product research. Italy remains the only commercial sales scope; foreign signals are research-only. The tool accepts only closed semantic fields and never creates a product or order.
| Name | Required | Description | Default |
|---|---|---|---|
| country | No | Legacy 1.2.0 compatibility for Italian demand. Omit it when origin_market is supplied. | |
| urgency | No | How soon the capability would be useful; defaults to exploratory. | |
| recurrence | No | Whether the need is one-off, recurring or continuous; defaults to unknown. | |
| budget_band | No | Optional coarse willingness-to-pay band in EUR; never send payment data. | |
| need_action | Yes | Primary action the machine wants the capability to perform. | |
| need_domain | Yes | Broad business domain of the requested capability; use other only when none applies. | |
| need_object | Yes | Business object or subject on which the action should operate. | |
| customer_type | Yes | Only business demand is observed; this does not expand commercial eligibility. | |
| origin_market | No | Self-declared coarse origin bucket used only for aggregate research; defaults to UNKNOWN_NOT_DECLARED. Foreign buckets never enable sales. | |
| desired_output | Yes | Machine-readable or operational result the buyer wants. | |
| existing_product_fit | No | Whether an existing MachineSignal product appears to fit; defaults to unknown. |
Output Schema
| Name | Required | Description |
|---|---|---|
| scope | Yes | |
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
| signal_type | Yes | |
| order_created | Yes | |
| origin_market | Yes | |
| persists_data | Yes | |
| mapping_status | Yes | |
| need_signature | Yes | |
| product_created | Yes | |
| free_text_accepted | Yes | |
| buyer_data_accepted | Yes | |
| market_verification | Yes | |
| existing_product_fit | Yes | |
| checkout_url_returned | Yes | |
| potential_product_gap | Yes | |
| provider_call_enabled | Yes | |
| commercial_eligibility | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds valuable behavioral context: 'never creates a product or order', 'accepts only closed semantic fields', and distinguishes commercial vs research scope for different markets. No contradictions.
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 concise sentences, front-loaded with the primary action, and each sentence adds essential information (purpose, scope, constraints). No waste.
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 (11 parameters, 5 required, output schema present), the description covers purpose, behavioral traits, and market scope. It could be improved by adding usage guidance relative to siblings, but overall it is nearly 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% with detailed descriptions for each parameter. The tool description adds no additional parameter-level semantics beyond what is already in the schema, so baseline 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 tool maps structured B2B business needs for aggregate product research, specifying scope (Italy vs foreign) and constraints (closed fields, no product/order creation). It implicitly differentiates from siblings like 'prepare_order_intent', but does not explicitly name alternatives, so not 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 provides no explicit guidance on when to use this tool versus sibling tools (e.g., check_buyer_fit, get_product_catalog). It does not state prerequisites or cases where the tool should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prepare_order_intentPrepare a local MS-DEC-250 order-intent templateARead-onlyIdempotentInspect
Return the canonical endpoint, OpenAPI, 17 required fields and a locally fillable MS-DEC-250 template. It accepts no buyer data and never creates an order.
| Name | Required | Description | Default |
|---|---|---|---|
| product_code | Yes | Entry product whose order-intent template should be prepared locally without submitting it. |
Output Schema
| Name | Required | Description |
|---|---|---|
| boundaries | Yes | Permanent safety boundaries of the public MCP discovery server. |
| instructions | Yes | |
| product_code | Yes | |
| order_created | Yes | |
| order_openapi | Yes | |
| persists_data | Yes | |
| submit_method | Yes | |
| order_endpoint | Yes | |
| required_fields | Yes | |
| accepts_buyer_data | Yes | |
| idempotency_header | Yes | |
| preparation_status | Yes | |
| request_schema_ref | Yes | |
| local_fill_template | Yes | |
| static_order_openapi | Yes | |
| checkout_url_returned | Yes | |
| provider_call_enabled | Yes | |
| validation_profile_url | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: 'It accepts no buyer data and never creates an order,' reinforcing safety and clarifying constraints 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?
Two sentences with no fluff. The description is front-loaded with the key action and output, making it 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter, rich annotations, and presence of an output schema, the description covers all necessary information: what is returned, what is not done, and input constraints. No gaps.
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 a clear description for product_code. The tool description adds no additional meaning beyond the schema, which is adequate. Baseline 3 applies per guidelines.
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 what the tool does: 'Return the canonical endpoint, OpenAPI, 17 required fields and a locally fillable MS-DEC-250 template.' It uses specific verbs and resources, distinguishing it from sibling tools like check_buyer_fit or get_product_catalog.
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 when to use (preparing a local template) and clarifies what it does not do ('never creates an order'), but it does not explicitly mention when not to use or provide alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Servers
- Alicense-qualityAmaintenanceValidates email deliverability, assesses domain credibility, and scores B2B leads from A-F to help prioritize outreach, with batch processing and a free tier.MIT
- AlicenseAqualityBmaintenanceAI-powered lead qualification engine. Ingest leads from any source, auto-enrich with company data, score 0-100 using weighted AI rules, and export to HubSpot, Pipedrive, Google Sheets, CSV, or JSON. 8 MCP tools + 3 resources.1048MIT
- AlicenseBqualityAmaintenanceEnables monitoring Italian public funding opportunities, normalizing them into a canonical model, and ranking them against a company profile with a two-stage matcher.62MIT
- AlicenseBqualityDmaintenanceEnables AI-assisted B2B lead generation by discovering, extracting, scoring, and exporting company leads from any MCP-compatible agent.311MIT