Protheus Research MCP Server
It is an MCP server that equips AI coding agents with authoritative TOTVS Protheus domain knowledge and diagnostics.
Search official Protheus documentation (TDN, Central de Atendimento, framework docs) with optional module/version filters.
Search community sources (forums, blogs, GitHub, Stack Overflow) for practical examples and workarounds.
Search release notes, LIB updates, patches, breaking changes, and deprecated functions.
Compare multiple sources on a topic to identify agreements, contradictions, and version-specific differences.
Run deep multi-source research producing a complete technical report with best practices, code examples, and version considerations.
Generate production-ready ADVPL/TL++/SQL/REST/SOAP/MVC code examples following modern Protheus standards.
Debug Protheus runtime errors, stack traces, and AppServer logs with probable causes, fixes, and prevention steps.
Provides structured access to TOTVS Protheus technical documentation, community knowledge, and release notes, enabling AI agents to search docs, cross-reference sources, generate ADVPL/TL++ examples, and debug runtime errors in the Protheus ecosystem.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Protheus Research MCP Serversearch official Protheus docs for error handling in ADVPL"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Protheus Research MCP Server
Private Model Context Protocol (MCP) Server for TOTVS Protheus Enterprise Architecture & Diagnostics
English | Português (Brasil)
A specialized Model Context Protocol (MCP) middleware engineered to equip AI coding agents with domain-specific intelligence, structured documentation retrieval, stack trace heuristic diagnostics, and canonical ADVPL/TL++ syntax standards across the TOTVS Protheus ecosystem.
Table of Contents
Related MCP server: GenZ MCP Server
Concept & Rationale
Software engineering within the TOTVS Protheus ERP environment presents distinct domain challenges:
Proprietary language syntaxes (ADVPL, TL++) that standard, general-purpose LLMs frequently misinterpret or hallucinate.
Extensive, disparate documentation repositories across TDN (TOTVS Developer Network), technical issue bulletins, and release notes.
Complex AppServer runtime execution behaviors, including memory management quirks, database cursors (
GetNextAlias,ChangeQuery), and runtime stack traces (Access Violations, Array Bounds, lock contention).
The Protheus Research MCP Server operates as a structured semantic bridge. Conforming strictly to the Model Context Protocol (MCP) specification, it exposes clean, deterministic tools that AI agent platforms (such as Claude, Cursor, OpenCode, and Antigravity) invoke dynamically to ground their code suggestions and architectural diagnostics in authoritative technical facts.
System Architecture
The server runs as a state-isolated daemon communicating via the standard JSON-RPC 2.0 protocol over standard input/output (stdio):
graph TD
subgraph AI Host Environment
Agent[AI Agent / LLM Host<br/>Claude / Cursor / OpenCode / Antigravity]
ClientTransport[MCP Client Transport]
end
subgraph Protheus Research MCP Engine
StdioTransport[StdioServerTransport<br/>JSON-RPC 2.0]
Router[Tool Execution Router]
Cache[In-Memory TTL Cache<br/>600s TTL / Deduplication]
subgraph Toolset [Registered Capabilities]
T1[search_protheus_docs]
T2[search_community]
T3[search_release_notes]
T4[compare_sources]
T5[deep_research]
T6[generate_advpl_example]
T7[debug_protheus_error]
end
Ranker[Source Ranker & Normalizer]
Heuristic[Error Categorization Matrix]
end
subgraph External Technical Knowledge
TDN[(TOTVS TDN / Central de Atendimento)]
GH[(Official TOTVS Repositories)]
COMM[(Recognized Community Portals)]
end
Agent <-->|JSON-RPC Tools| ClientTransport
ClientTransport <-->|stdio stream| StdioTransport
StdioTransport --> Router
Router --> Cache
Router --> Toolset
T1 & T2 & T3 & T4 & T5 --> Ranker
T7 --> Heuristic
Ranker --> TDN & GH & COMMCore Subsystems
Protocol Core (
src/index.ts): Implements the official@modelcontextprotocol/sdkschemas (ListToolsRequestSchema,CallToolRequestSchema), handling tool discovery, parameter validation, and structured error responses.Deterministic Source Ranker (
src/services/searcher.ts): Prioritizes official TOTVS documentation domains (tdn.totvs.com,centraldeatendimento.totvs.com) as Level 1 authoritative sources, indexing recognized technical community portals as Level 2 advisory references.Error Heuristic Engine (
src/tools/debugError.ts): Pattern-matching matrix analyzing raw Protheus AppServer error logs, categorizing failure classes (Array Bounds, Access Violations, Deadlocks, REST/SOAP faults, Database timeouts), and returning structured remediation workflows.Code Synthesis Engine (
src/tools/generateExample.ts): Produces standard-compliant ADVPL, TL++, and Embedded SQL patterns adhering strictly to modern Protheus guidelines (Localvariable scoping, logical deletion handling, and cross-RDBMS query wrappers).In-Memory Cache (
src/utils/cache.ts): Fast, key-value TTL store preventing outbound duplicate requests and upstream rate-limiting during recursive multi-step reasoning runs.
Agent Tool-Call Lifecycle
sequenceDiagram
autonumber
actor Engineer as Software Engineer
participant Agent as AI Agent (Claude / Cursor / Antigravity)
participant MCP as Protheus Research MCP Server
participant Cache as In-Memory Cache
participant Engine as Search & Parser Pipeline
participant Sources as TDN & Knowledge Portals
Engineer->>Agent: "Diagnose AppServer error: array out of bounds in U_MYFUNC"
Agent->>MCP: CallToolRequest("debug_protheus_error", { errorMessage: "...", stackTrace: "..." })
MCP->>Cache: Check cached diagnostic fingerprint
alt Cache Hit
Cache-->>MCP: Return cached diagnosis
else Cache Miss
MCP->>MCP: Execute heuristic error classification
MCP->>Engine: Dispatch targeted documentation search
Engine->>Sources: Query TDN articles & known issues
Sources-->>Engine: Raw documentation snippets & URLs
Engine->>MCP: Normalized, relevance-scored references
MCP->>Cache: Store result (10-minute TTL)
end
MCP-->>Agent: CallToolResult(Structured diagnosis, root causes, corrective code)
Agent-->>Engineer: Synthesizes precise root cause and validated ADVPL patchTool Suite Specification
Tool Identifier | Scope | Technical Function |
| Official Docs | Queries TDN, Central de Atendimento, and official TOTVS frameworks with optional module and version scoping. |
| Diagnostics | Heuristic pattern analysis classifying runtime crashes, stack traces, and AppServer dumps with remediation steps. |
| Code Synthesis | Generates production-ready, canonical ADVPL, TL++, Embedded SQL, and FWRest boilerplate adhering to TOTVS modern guidelines. |
| Correlation | Orchestrates autonomous multi-tier research cross-referencing documentation, release notes, and community solutions. |
| Comparison | Cross-verifies competing implementation approaches or legacy vs. modern framework methods. |
| Community Hubs | Queries curated developer portals and forums for field-tested workarounds and niche customizations. |
| Lifecycle | Checks issue resolutions, cumulative update packages, and framework changes across Protheus releases. |
Tool Schemas & Payloads
1. search_protheus_docs
// Input Schema
{
"query": "FWRest",
"module": "SIGAFAT",
"version": "12.1.2210"
}
// Sample Output Payload
{
"results": [
{
"title": "FWRest - Framework ADVPL - TDN",
"url": "https://tdn.totvs.com/display/tec/FWRest",
"snippet": "Classe para consumo de serviços RESTful em ADVPL, suportando métodos HTTP padronizados, SSL e manipulação de cabeçalhos.",
"sourceType": "official_tdn",
"sourceLevel": 1,
"relevance": 95
}
],
"totalFound": 12
}2. debug_protheus_error
// Input Schema
{
"errorMessage": "array out of bounds [0] of [1] on U_MYFUNC(MYFUNC.PRW)",
"stackTrace": "U_MYFUNC (MYFUNC.PRW) 15/08/2026 14:22:01",
"environment": "Protheus 12.1.2210, SQL Server 2019"
}
// Sample Output Payload
{
"diagnosis": "Category: Array Bounds. 6 authoritative references located.",
"probableCauses": [
"Attempting to read index <= 0 or beyond array length (Len(aArray)).",
"Empty dataset returned by query/DbSeek without length validation prior to indexing."
],
"verificationSteps": [
"Inspect AppServer console log for full execution context.",
"Verify RPO compilation status and dictionary synchronization."
],
"fixes": [
"Enforce defensive boundary checks using If Len(aData) >= nIndex before accessing aData[nIndex].",
"Initialize dynamic collections safely using AAdd() or aClone()."
]
}3. generate_advpl_example
// Input Schema
{
"language": "advpl",
"description": "Query customers from SA1 with logic deletion handling and JSON serialization",
"context": "Faturamento (SIGAFAT)"
}
// Sample Output Payload
{
"language": "advpl",
"bestPractices": [
"Enforce explicit Local variable declarations for predictable memory scope.",
"Use GetNextAlias() to avoid cursor collisions in concurrent threads.",
"Apply ChangeQuery() for cross-database portability.",
"Always verify logical deletion flag (D_E_L_E_T_)."
]
}Security & Enterprise Isolation
Air-Gapped Operation: The server operates strictly as an analytical knowledge middleware. It does not establish direct connections to customer production ERP databases, DBAccess ports, or live transactional tables.
Zero Sensitive Data Ingestion: The engine does not store, transmit, or process client business records, ERP credentials, or proprietary business logic.
Controlled Outbound Communication: Web requests are strictly confined to public documentation hosts (TDN, Central de Atendimento, GitHub) over standard TLS/HTTPS.
System Scope
This repository documents the architectural blueprint, design patterns, and capability contracts of the Protheus Research MCP Server. As a private enterprise asset tailored to specialized development environments, public distribution packages, automated build artifacts, and client environment configurations are maintained outside public repositories.
Legal Disclaimer
TOTVS, Protheus, ADVPL, and TL++ are registered trademarks of TOTVS S.A. This project is an independent developer productivity and architectural research middleware. It is neither affiliated with, sponsored by, nor endorsed by TOTVS S.A.
License
All rights reserved. Proprietary software. Refer to LICENSE for terms.
Available Tools
7 toolscompare_sourcesA
Compare multiple information sources (official vs community) on a given topic. Identifies agreements, contradictions, and version-specific differences. Useful when documentation is conflicting or unclear.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Technical topic to compare across sources | |
| topics | No | Specific subtopics to analyze for agreements/contradictions |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses that the tool compares official and community sources and identifies agreements, contradictions, and version differences. However, it doesn't detail underlying source mechanisms, potential limitations, or return format.
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 concise sentences that cover purpose, behavioral outcomes, and usage context without any 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?
For a 2-parameter tool with no output schema, the description provides purpose, behavioral expectations, and usage context. It doesn't specify return format, but the 'Identifies...' phrasing gives a reasonable idea of the output.
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%, and both parameters are already described in the schema. The tool description adds no parameter-specific information, so the baseline 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 specifies the verb 'Compare' and the resource 'multiple information sources (official vs community) on a given topic.' It also states the key outputs (agreements, contradictions, version-specific differences), which distinguishes it from sibling search tools.
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 provides a use case: 'Useful when documentation is conflicting or unclear.' This gives a clear context, although it doesn't mention when not to use it or alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
debug_protheus_errorA
Investigate Protheus runtime errors, stack traces, AppServer logs, and common failures. Combines official and community knowledge for diagnosis, probable causes, fixes, and prevention. Supports: Access Violations, Array Bounds, Deadlocks, REST/SOAP failures, DBAccess errors, License errors, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| stackTrace | No | Optional stack trace to aid diagnosis | |
| environment | No | Optional environment info (e.g., "Protheus 12.1.33, SQL Server 2019") | |
| errorMessage | Yes | The error message or description |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool combines official and community knowledge and provides diagnosis, probable causes, fixes, and prevention. This gives a clear sense of its behavior and output, though it omits details like rate limits or response format.
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, front-loaded with the main purpose. Every sentence adds value: what it does, how it combines knowledge, and the supported error types. No fluff 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 moderate complexity and absence of annotations/output schema, the description covers the key aspects: domain, supported error families, and output categories (diagnosis, causes, fixes, prevention). It does not specify exact return format or limitations, but is adequate for an analysis tool.
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 schema already provides 100% coverage, clearly describing errorMessage, stackTrace, and environment. The tool description adds no extra parameter meaning, so the baseline 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 'Investigate[s] Protheus runtime errors, stack traces, AppServer logs, and common failures,' with a specific verb and resource scope. It also enumerates supported error types (Access Violations, Deadlocks, etc.), distinguishing it from sibling search tools like search_protheus_docs.
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 use when encountering Protheus runtime errors and lists supported categories, giving clear context for when it applies. However, it does not explicitly mention alternatives or exclusions, such as 'use search_protheus_docs for documentation lookups instead.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
deep_researchA
Orchestrate comprehensive research across ALL sources for a Protheus topic. Aggregates results, ranks sources by reliability, removes duplicates, and produces a complete technical report with summary, explanation, official docs, community findings, best practices, common mistakes, code examples, and version considerations.
| Name | Required | Description | Default |
|---|---|---|---|
| depth | No | Research depth: quick (2-4 sources), intermediate (5-8), deep (exhaustive) | intermediate |
| query | Yes | The main research query | |
| modules | No | Protheus modules to focus on (e.g., ["FAT", "FIN", "EST"]) | |
| versions | No | Protheus versions to check (e.g., ["12.1.25", "12.1.33"]) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does disclose several behavioral traits: aggregates results, ranks by reliability, removes duplicates, and produces a detailed report. However, it omits potential side effects, dependencies, or limitations (e.g., no mention of network calls, rate limits, or that it is purely read-only).
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 front-loaded with the primary purpose and then details the output components. While the list of report elements is long, each item adds meaningful context. No wasted words, but it could be slightly more concise by trimming the exhaustive list.
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 no output schema, the description does a good job explaining the return value (a technical report with specific sections). It also covers the scope (across ALL sources) and the research process. It doesn't address how depth modifies behavior, but the schema's enum description partially covers that.
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 schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds some semantic reinforcement (e.g., 'version considerations' aligns with versions parameter), but it doesn't provide syntax, format, or usage details beyond what the schema already includes.
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 uses a specific verb ('Orchestrate') and clearly defines the resource ('comprehensive research across ALL sources for a Protheus topic'). It distinguishes from siblings by emphasizing aggregation and report generation, unlike the targeted search tools like search_protheus_docs or search_community.
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 clearly implies this is the go-to tool for comprehensive research across all sources, while siblings handle specific searches. It does not explicitly state exclusions but the 'ALL sources' phrase provides clear context for when to use it over more focused alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_advpl_exampleA
Generate production-ready, modern ADVPL/TL++ code examples based on researched material. Supports ADVPL, TL++, SQL, REST, SOAP, and MVC patterns. Code follows modern standards: LOCAL variables, Framework APIs, SQL Server syntax, no obsolete patterns.
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | Additional context (e.g., table name, module, business rule) | |
| language | Yes | Target language or pattern | |
| description | Yes | What the code should do |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description holds the burden for behavioral disclosure. It discloses quality standards ('production-ready', 'modern standards', 'no obsolete patterns') and scope (supported patterns). However, it does not disclose return format, potential failure modes, or any dependencies beyond 'researched material', leaving some ambiguity.
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, front-loaded with the action, and every sentence adds value: action, supported patterns, and quality standards. No redundancy or filler.
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 tool's scope and quality but omits what the output looks like (e.g., a code snippet, multiple examples, file structure). Since there is no output schema, this is a gap. However, given the tool's name and clear purpose, it is adequately scoped for simple generation tasks, making a 3 appropriate.
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 schema already covers all three parameters with clear descriptions and an enum for language, so the description does not need to add much. It adds only minor context like 'SQL Server syntax', which reinforces the SQL parameter but does not meaningfully enhance understanding beyond the schema. Baseline of 3 is appropriate given 100% schema coverage.
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 specific action ('Generate') and resource ('production-ready, modern ADVPL/TL++ code examples'), and enumerates supported patterns (ADVPL, TL++, SQL, REST, SOAP, MVC). This distinguishes it from sibling tools, which are research/search-oriented, by emphasizing code generation.
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 phrase 'based on researched material' provides clear context that this tool should be used after research tools like deep_research or search_protheus_docs. It implicitly sets an expectation for prior information gathering, though it does not explicitly name alternatives or exclusions, which keeps it just below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_communityA
Search trusted Protheus community sources: Terminal de Informação, BlackTDN, MasterADVPL, Universo ADVPL, GitHub, Stack Overflow, and technical blogs. Use this to find practical examples, workarounds, and real-world experiences.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for community resources | |
| includeForums | No | Include forums (Reddit, Stack Overflow) in results |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what sources are searched and the type of content found, but it does not disclose expected result format, potential latency, reliability of community content, or whether network access is required. This is adequate for a read-only search but lacks some behavioral context.
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 and immediately states the action and key purpose. It lists sources concisely and then provides the use case. No wasted words or redundancy with the schema or title.
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 is fairly complete: it names sources, explains the intended use, and differentiates from siblings. It does not mention the return value structure, but for a search tool this may be less critical. It also lacks caveats about community-generated content quality, but overall it covers the essential context.
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 schema covers 100% of the parameters, so the baseline is 3. The description adds no additional meaning beyond the schema—'query' and 'includeForums' are self-explanatory in the schema. There is no extra guidance on how to craft effective queries or when to enable forums.
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 (search), the resource (trusted Protheus community sources), and enumerates specific sources (Terminal de Informação, BlackTDN, etc.). It also clarifies the purpose (find practical examples, workarounds, real-world experiences), which distinguishes it from sibling search_protheus_docs (docs) and search_release_notes (release notes).
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 says 'Use this to find practical examples, workarounds, and real-world experiences,' providing clear context for when to invoke this tool. It does not explicitly mention when not to use it or name sibling alternatives, but the use-case phrasing conveys the intended scope compared to documentation/release searching.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_protheus_docsA
Search official TOTVS Protheus documentation across TDN, Central de Atendimento, Framework docs, and Release Notes. Use this tool when you need authoritative, official TOTVS documentation for any Protheus-related topic. Always prefer this over community sources for factual technical information.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Technical search query (e.g., "TCSQLExec", "FWRest POST", "SX6 MV_PARXX") | |
| module | No | Optional Protheus module filter (e.g., "SIGAFAT", "SIGAFIN", "SIGAEST") | |
| version | No | Optional Protheus version filter (e.g., "12.1.25", "12.1.33") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the exact data sources searched ('TDN, Central de Atendimento, Framework docs, and Release Notes') and frames the tool as authoritative, but it does not describe result format, pagination, or query limitations. Read-only behavior is implied by 'Search' rather than stated.
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, front-loaded with the core action and source scope. The guidance is useful though slightly redundant ('authoritative'/'official' and repeated preference over community sources), but no sentence is wasteful.
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 docs-search tool with three well-documented parameters and no output schema, the description covers scope, source set, and usage policy. It could add what the response contains or how version/module filters behave, but the essential context for selecting and invoking the tool is present.
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. The description adds no parameter-specific meaning beyond the schema; query, module, and version are already documented with examples. 'Any Protheus-related topic' loosely frames query scope but doesn't enhance understanding of module/version filters.
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 states 'Search official TOTVS Protheus documentation across TDN, Central de Atendimento, Framework docs, and Release Notes' – a specific verb, resource, and source scope. The word 'official' clearly distinguishes it from sibling search_community.
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 says 'Use this tool when you need authoritative, official TOTVS documentation for any Protheus-related topic' and 'Always prefer this over community sources for factual technical information.' It gives clear when-to-use context and contrasts with community sources, though it does not name specific sibling alternatives or negative cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_release_notesA
Search for TOTVS Protheus release notes, LIB updates, patches, behavior changes, breaking changes, and deprecated functions across versions.
| Name | Required | Description | Default |
|---|---|---|---|
| patch | No | Optional patch number | |
| product | Yes | Product name (e.g., "Protheus", "Framework", "SIGAFAT") | |
| version | No | Optional version filter (e.g., "12.1.33") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses the search scope (release notes, patches, etc.) and the cross-version capability, but does not mention result format, pagination, or any limitations, leaving some behavioral aspects unspecified.
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, succinct sentence that starts with the action verb 'Search' and enumerates the specific resource types. No filler or redundant phrasing.
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 three parameters fully described in the schema, the description conveys the fundamental purpose effectively. However, without an output schema, it could have described the return value shape, but the core topic coverage is sufficient.
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 covers 100% of parameters with descriptions, so the schema already handles parameter semantics. The description adds no extra param-specific context beyond what the schema provides, earning the baseline 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 tool searches TOTVS Protheus release notes and related topics (LIB updates, patches, behavior changes, breaking changes, deprecated functions). This is a specific verb+resource combination that distinguishes it from sibling tools like search_protheus_docs or search_community.
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?
No guidance is provided on when to use this tool versus the alternatives. There is no mention of exclusions, when to prefer another sibling, or when this tool is most appropriate.
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.
7 tool updates
v1.0.0- First observed
compare_sources - First observed
debug_protheus_error - First observed
deep_research - First observed
generate_advpl_example - First observed
search_community - First observed
search_protheus_docs - First observed
search_release_notes
TDQS
Scored across 7 tools
Each tool has a clear primary purpose, and the distinctions between search_protheus_docs, search_community, and search_release_notes are well-defined by source type. There is slight overlap between search_protheus_docs and search_release_notes since release notes are part of official docs, but the descriptions reduce ambiguity.
All tool names follow a consistent snake_case verb_noun pattern: search, compare, generate, debug. Even 'deep_research' fits the pattern as a verb-like compound. No mixed conventions or inconsistent casing.
Seven tools is well within the ideal 3-15 range for a focused research and assistance server. Each tool covers a distinct aspect of the Protheus ecosystem, and none feel redundant or unnecessary.
The tool surface covers the full research lifecycle: searching official and community sources, checking release notes, comparing sources, running deep aggregated research, generating code examples, and debugging errors. This leaves no obvious dead ends for common Protheus developer tasks.
Maintenance
Related MCP Connectors
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Related MCP Servers
- AlicenseBqualityCmaintenanceAn MCP server that supercharges AI assistants with powerful tools for software development, enabling research, planning, code generation, and project scaffolding through natural language interaction.1153 npm103MIT
- FlicenseNot gradedqualityDmaintenanceA streamlined MCP server that provides essential AI-powered tools for interactive development chat and systematic root cause analysis. It supports multiple AI providers to help developers brainstorm technical solutions and perform evidence-based debugging.-
- AlicenseNot gradedqualityAmaintenanceAn MCP server that provides tools for retrieving and processing documentation through vector search, enabling AI assistants to augment their responses with relevant documentation context.19 npmMIT
- AlicenseNot gradedqualityDmaintenanceMCP tool server that gives any AI agent the ability to search, scrape, and analyze content across the internet.41MIT