SEFAZ GO: Produtor Rural
Server Details
SEFAZ GO: Produtor Rural, official-source lookup. Platform-hosted, pay per query with prepaid credit
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- mcp-dir/sefaz_go_produtor_rural-mcp
- GitHub Stars
- 0
- Server Listing
- SEFAZ GO: Produtor Rural
TDQS
Scored across 7 tools
The tools are largely distinct: authenticate and connect have some overlap but are differentiated by action (obtaining credentials vs. checking status), and marketplace vs. report_bug vs. sefaz tools are clearly separate. Minor ambiguity remains between authenticate and connect.
Naming is inconsistent: some tools use verbs (authenticate, connect, show_version), others use nouns (marketplace, toolkit_info), and one is a specific domain name (sefaz_go_produtor_rural_consultar). The mix of conventions and lack of a uniform pattern hurts predictability.
With 7 tools, the server is appropriately scoped for a meta-toolkit that manages MCPs and provides one domain-specific consultation. The count is neither sparse nor bloated.
The toolkit covers essential management operations: authentication, connection status, marketplace search/invoke, version info, and state reporting. The single domain-specific tool is limited but fits the server's stated purpose, with only minor gaps like direct uninstall or configuration editing.
Available Tools
7 toolsauthenticateAIdempotentInspect
MCP.AI for IDE agents (Cursor, etc.): log in in the browser, copy the access token. Best: add it to this server's config as a header Authorization: Bearer <token> for a permanent, non-expiring connection. Or paste it here for a session-only login: call with { token: "" } after the user pastes, or with no args to get the link.
| Name | Required | Description | Default |
|---|---|---|---|
| token | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds transparency beyond annotations by explaining the dual nature (permanent vs session) and that no args returns a link. It implies side effects (modifying server config) but does not contradict the idempotentHint and non-destructive annotations. The added context about permanent vs session is valuable.
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 somewhat lengthy but each sentence adds essential information: how to obtain the token, permanent vs session usage, and fallback to get the link. No superfluous content; it is appropriately detailed for the complexity.
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 description covers the main behavioral aspects: how to authenticate, what arguments to pass, and the distinction between permanent and session modes. Since there is no output schema, it does not need to explain return values, but it could have mentioned the expected response format for completeness. Overall, it is complete enough for typical usage.
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 single parameter `token` is clearly explained: it is the JWT to be used for session login, and the description notes that it is optional (can call with no args to get the link). This fully covers the schema's minimal definition.
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: authenticating the user via a browser login and token, with options for permanent or session-based access. It distinguishes itself from sibling tools like 'connect' and 'marketplace' by focusing solely on authentication.
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 explicit usage instructions, explaining the best practice (adding token to server config for permanent connection), alternative (session-only login), and how to invoke (with or without args). It does not explicitly compare to other tools, but the usage context is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
connectARead-onlyIdempotentInspect
Returns connection status and URLs. When all providers are connected, returns authenticated:true and empty pending[]. When credentials are missing, returns connect_url for the toolkit and per-install URLs.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly, idempotent, non-destructive, so the description adds context about return states (authenticated true vs connect_url). It doesn't mention auth requirements or rate limits beyond what's implied. No 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?
Description is two sentences, front-loaded with the purpose, and provides only necessary details. Zero 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?
Without output schema, the description explains key return values (authenticated flag, pending[], connect_url). It's complete for its simplicity, but lacks explicit note about per-install URLs 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?
No parameters exist, so description's job is minimal. It provides enough context about behavior without needing to explain parameters. Baseline for 0 params is 4.
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 returns connection status and URLs, with specifics about two states (all connected vs missing credentials). It distinguishes from siblings like authenticate (action) and shows connection state info, but doesn't explicitly differentiate from toolkit_info.
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: to check connection status, especially when credentials may be missing. It doesn't explicitly exclude alternatives like authenticate, but the context makes it clear for status checking.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
marketplaceAInspect
The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them. Covers capability requests like "find an MCP that does X", "consulta um CPF", "is there a tool for Y". Core flow: action=search discovers MCPs by intent → describe returns one MCP's full profile (every tool with its id + params, pricing, auth) so you pick the right tool_id → invoke RUNS that tool. KEY: invoke works even when the MCP is NOT installed — it runs the tool pontualmente (one-off), without adding the MCP to the toolkit and without bloating the tool list. If the MCP needs a credential/login, invoke returns a connect link; if it is paid and the wallet is empty, invoke returns a checkout/top-up link (the user opens it, then you retry). Use install only to make an MCP PERMANENT in the active toolkit (its tools then show up natively in future sessions); prefer invoke for a single/occasional use. list_tools lists what is callable right now. subscribe/cancel handle per-MCP billing; report_bug sends feedback; request_mcp asks us to build a NEW MCP when nothing fits. Search/describe flag installed_in_toolkit vs installed_in_workspace. Writes (install/uninstall/subscribe/cancel and the one-off install behind invoke) require workspace owner/admin. It also carries the mcp.ai PROMPT LIBRARY, which is about ready-made prompt TEXT rather than MCPs: search_prompts finds one, get_prompt returns its full text with {{variables}} filled, and publish_prompt saves a prompt and returns a shareable mcp.ai/p/ link that opens without login.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | No | ||
| action | No | search | |
| mcp_id | No | ||
| message | No | ||
| tool_id | No | ||
| arguments | No | {} | |
| immediate | No | ||
| tier_slug | No | ||
| prompt_body | No | ||
| prompt_slug | No | ||
| prompt_tool | No | ||
| prompt_vars | No | {} | |
| conversation | No | [] | |
| prompt_title | No | ||
| request_name | No | ||
| cancel_reason | No | ||
| cancel_comment | No | ||
| prompt_targets | No | ||
| report_context | No | ||
| prompt_category | No | ||
| request_details | No | ||
| prompt_description | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description discloses key behaviors: it mentions writes require workspace owner/admin, that invoke can run tools without installing them, that auth/paywall issues surface as links, and that catalog entries flag install status. These are significant behavioral disclosures that significantly aid agent decision-making.
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 detailed yet efficiently organized, front-loading the core flow, devoting focused segments to invocation side effects, installation, billing, and the prompt library. No sentence is wasted; each adds distinct value. Despite its length, the density and clear structure merit a top score.
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?
This is a highly complex tool with a broad set of actions, but the description covers each action's purpose, side effects, and typical use cases. It also explains return behaviors (links for auth/payment, profiles from describe) even though no output schema exists. The inclusion of admin requirements and the prompt library further completes the picture.
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 23 parameters and 0% schema description coverage, the description carries heavy responsibility. It provides context for many parameters through its narrative (e.g., action, mcp_id, tool_id, prompt_* fields) but does not explicitly explain every parameter (e.g., limit, query, conversation, arguments). However, it compensates partially by explaining the action flow, which renders many parameters self-evident. Still, some parameters like `conversation` are undefined, leaving gaps.
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 provides a comprehensive overview of the marketplace tool with specific verbs and resources: it explains the core search-describe-invoke flow, differentiates the actions (search, describe, install, invoke, etc.), and clarifies the difference between permanent installation and one-off invocation. It also contrasts with sibling tools (like authenticate, connect) by positioning itself as the catalog and execution platform.
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 gives actionable guidance: it instructs to use `invoke` for single/occasional use and `install` for permanent MCPs, states when credentials or payment are needed, and directs users to `subscribe`/`cancel` for per-MCP billing and `request_mcp` when nothing fits. It also explains the prompt library separate from MCPs, ensuring correct selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
report_bugAIdempotentInspect
Report a bug, missing feature, or send feedback. Include the conversation array with recent messages for reproduction.
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | ||
| message | Yes | ||
| conversation | No | [] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate the tool is not read-only and is idempotent, which aligns with the description's implication of submitting a report. The description adds the detail about including conversation for reproduction, but does not describe side effects beyond that. It does not contradict 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, with two clear sentences and no unnecessary detail. It is well-structured and easy to parse.
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 low parameter coverage, the description should clarify all parameters but only addresses conversation. It also lacks any mention of the expected output or return value, making it incomplete for a tool with minimal schema annotation.
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 very low (0% descriptions). The description only clarifies the 'conversation' parameter as an array for reproduction, but does not explain 'message' (which is required) or 'context'. This leaves significant ambiguity about their meanings.
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: reporting bugs, missing features, or sending feedback. It also mentions the inclusion of a conversation array for reproduction, which adds specificity.
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 for bug/feedback reporting but does not explicitly contrast with alternative tools or provide context on when not to use it. The purpose is clear enough that usage is inferable, but guidance is minimal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sefaz_go_produtor_rural_consultarARead-onlyIdempotentInspect
SEFAZ GO: Produtor Rural, consulta em fonte oficial. Hospedado pela plataforma, sem credenciais da plataforma, pague por consulta com crédito pré-pago. Consulta informação de fontes e órgãos oficiais brasileiros (a mesma disponível ao cidadão), não é dado sigiloso. O cliente é o controlador dos dados e responde pela finalidade legítima (LGPD).
| Name | Required | Description | Default |
|---|---|---|---|
| ie | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate a safe read-only, idempotent, non-destructive operation. The description adds valuable context about the external data source, pay-per-query cost, non-confidential data nature, and LGPD responsibility, which informs the agent of important side effects 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 moderately sized and front-loaded with the primary purpose. It contains several distinct facts—official source, hosting, payment, data nature, legal compliance—each contributing value, with minimal 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?
As a simple one-parameter read operation, the description covers the data source and legal context but omits the input parameter's meaning and any expected response structure. Since there is no output schema, more detail on return values would be needed for full completeness.
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 only parameter 'ie' is not described in either the schema or the description. With 0% schema description coverage, the description should compensate but fails to explain what 'ie' represents or its expected format, leaving the agent to guess it means Inscrição Estadual.
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 this tool is for consulting rural producer information from SEFAZ Goiás, using the verb 'consulta' and specifying the official source. It is distinct from sibling tools, which are platform-level utilities like authenticate or marketplace.
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 clear usage context: it uses official data, requires no platform credentials, and operates on prepaid credit. Although it does not explicitly name alternatives, sibling tools are unrelated, so the guidance is sufficient for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
show_versionARead-onlyIdempotentInspect
Show the current MCP platform and adapter versions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's a safe, non-mutating operation. The description adds no extra behavior details (e.g., output format), but given the trivial nature of the tool, this is acceptable. With annotations covering safety, the description does not need to repeat them.
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 precise sentence with zero redundancy. It fully conveys the tool's function in the most economical way possible.
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 zero-parameter tool with clear annotations and no output schema, the description is complete. It fully explains the tool's purpose without needing additional behavioral details.
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?
There are zero parameters; the schema is fully covered at 100%. With no parameters to describe, the description needs no parameter-level guidance. Baseline of 4 is appropriate given the empty 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 the tool shows the current MCP platform and adapter versions, with a specific verb and resource. It is distinct from sibling tools like authenticate, connect, or marketplace, which serve different purposes.
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 intended usage is obvious: call when you need version information. While not explicitly stating alternatives, the description provides clear context and there are no overlapping tools that perform the same function.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
toolkit_infoARead-onlyIdempotentInspect
Returns the current toolkit state: installed MCPs, their connection status, the accounts connected to each one, and how many catalog tools each exposes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds substantial behavioral context by detailing the specific content returned (installed MCPs, connection status, accounts, catalog tool counts), going beyond what 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?
The description is a single, well-structured sentence that front-loads the core purpose and lists all included details. Every word 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, no output schema, and a simple informational role, the description fully explains what the tool returns and is sufficiently complete for an agent to know when and how to invoke it.
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 tool has zero parameters, so the baseline is 4. The description does not need to explain parameters since none exist, and it accurately focuses on the 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 verb 'Returns' and exactly what resource ('current toolkit state') with specific details (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools like connect and authenticate, which perform actions rather than return information.
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 for checking toolkit state, but does not explicitly state when to use it versus alternatives or mention any exclusions. However, given the tool's informational nature and zero parameters, the context is clear enough that an agent would know to call it when needing status information.
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. Dates show when Glama detected each change.
No tool schema history has been recorded yet.
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity – fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge – works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge – works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
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
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
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 Connectors
SEFAZ GO: NFC-e (Completa), official-source lookup. Platform-hosted, pay per query with prepaid cred
SEFAZ GO: Clearance Certificate (Debts), official-source lookup. Platform-hosted, pay per query with
SEFAZ GO: IPVA, official-source lookup. Platform-hosted, pay per query with prepaid credit.
SEFAZ GO: NFC-e, official-source lookup. Platform-hosted, pay per query with prepaid credit.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables querying SEFAZ's centralized taxpayer registration (CCC) from the official source via a read-only tool. Pay-per-use with prepaid credits.MIT
- AlicenseNot gradedqualityCmaintenanceMCP server to query Brazil's rural property registry (CAFIR) using the CIB code, providing read-only consultation of rural property data via a hosted API with prepaid credits.MIT
- AlicenseNot gradedqualityCmaintenanceEnables consultation of official SEFAZ GO NFC-e (Brazilian electronic invoice) data via a read-only MCP server with pre-paid credits.MIT
- AlicenseNot gradedqualityCmaintenanceEnables users to query the official Brazilian Regional Council of Dentistry (GO) registry for professional registration data through a read-only MCP server, with pay-per-use prepaid credits.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.