dom-explorer
Launches and controls a visible Google Chrome/Chromium browser for interactive DOM inspection, with visual overlays, highlighted elements, and click-to-select handling.
Generates Robot Framework Page Object resources with variables and reusable keywords, supporting both Browser Library and SeleniumLibrary locator syntax.
Creates SeleniumLibrary-compatible locators and Page Object resource files for the inspected DOM elements to be used in automated Robot Framework tests.
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., "@dom-explorerOpen https://example.com/login and generate a resilient Robot Framework locator for the email input"
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.
🌐 DOM Explorer MCP Server
Um servidor MCP (Model Context Protocol) e ecossistema de automação inteligente em Python para exploração interativa do Document Object Model (DOM) e geração de seletores e Page Objects resilientes para o Robot Framework (suportando tanto a Browser Library quanto a SeleniumLibrary).
🚀 Funcionalidades
Inspeção Interativa em Navegador Visível (Headful):
Abre uma janela real do Google Chrome / Chromium na URL fornecida.
Injeta automaticamente um script de overlay com destaque visual (bounding box), tooltip informativo e barra de controle flutuante.
Intercepta cliques de inspeção sem disparar navegações acidentais em botões ou links.
Alternância rápida entre Modo Inspeção e Modo Navegação Livre.
Extração Completa de Metadados do DOM:
Tags HTML, IDs, classes, nomes, placeholders, tipos e textos visíveis.
Atributos de acessibilidade (
role,aria-label) e de teste (data-testid,data-test,data-cy,data-qa).Hierarquia de elementos pais (parent chain) e coordenadas de renderização (bounding box).
Gerador de Locators & Variáveis para Robot Framework:
Converte seletores automaticamente para Browser Library (
id=...,role=button[name="..."],text="...",[data-testid="..."]) e SeleniumLibrary (id:...,name:...,xpath:...,css:...).Algoritmo de descarte de IDs dinâmicos de frameworks (como
:r0:,ext-gen-123,ember456).Nomenclatura padronizada de variáveis (ex:
${BTN_SUBMIT_LOGIN},${INPUT_EMAIL_USUARIO}).
Varredura Textual e Semântica (
scan_elements):Mapeia elementos em lote por tag, role ou texto visível direto pelo Agente sem precisar clicar em cada um manualmente.
Validação e Destaque Visual (
highlight_element):Testa qualquer seletor na página aberta, garantindo unicidade (
match_count == 1) e destacando-o na cor vermelha.
Exportação de Page Objects (
export_robot_resource):Gera arquivos
.resourcecompletos contendo*** Settings ***,*** Variables ***e*** Keywords ***reutilizáveis.
Related MCP server: LocatorLabs MCP Server
📦 Instalação e Configuração
Pré-requisitos
Python 3.10 ou superior.
Ferramenta uv instalada.
Instalação das Dependências
git clone <repo-url> dom-explorer
cd dom-explorer
# Sincronizar dependências do ambiente virtual
uv sync
# Instalar os binários do navegador Playwright
uv run playwright install chromium⚙️ Configuração nos Clientes MCP
1. Kilo Code
No Kilo Code, os servidores MCP são configurados dentro do arquivo principal de configuração do Kilo (kilo.jsonc ou .kilo/kilo.jsonc), sob a chave raiz "mcp".
Onde configurar:
Nível de Projeto (Recomendado): Crie ou edite
.kilo/kilo.jsonc(oukilo.jsonc) na raiz do seu projeto.Nível Global:
~/.config/kilo/kilo.jsonc(aplica-se a todos os projetos).
Via Interface do Kilo Code (VS Code Extension):
Clique no ícone de Configurações (⚙️) na barra lateral do Kilo Code.
Clique na aba Agent Behaviour à esquerda.
Acesse a sub-aba MCP Servers.
Clique em Add Server, selecione Local (stdio) e informe o comando.
Configuração JSON (.kilo/kilo.jsonc ou ~/.config/kilo/kilo.jsonc):
{
"mcp": {
"dom-explorer": {
"type": "local",
"command": [
"uv",
"run",
"--directory",
"/home/odoni_r/projects/dom-explorer",
"dom-explorer"
],
"enabled": true,
"timeout": 30000
}
},
"permission": {
"dom-explorer_*": "allow"
}
}Formato de comando: O campo
"command"deve ser uma lista com o executável e seus argumentos.Permissões automáticas: A chave
"permission": { "dom-explorer_*": "allow" }permite que o Kilo Code execute as ferramentas do DOM Explorer sem abrir caixas de diálogo para confirmação manual a cada inspeção de elemento.Verificação via CLI do Kilo: Você pode listar e depurar a conexão executando:
kilo mcp list kilo mcp debug dom-explorer
2. Antigravity IDE / Claude Desktop / Cursor
Adicione a entrada correspondente no seu arquivo de configuração (mcp_config.json ou claude_desktop_config.json):
{
"mcpServers": {
"dom-explorer": {
"command": "uv",
"args": [
"run",
"--directory",
"/home/odoni_r/projects/dom-explorer",
"dom-explorer"
]
}
}
}🛠️ Ferramentas Disponíveis no MCP (Tools)
Ferramenta | Parâmetros | Descrição |
|
| Abre o navegador na URL indicada e ativa o inspetor visual. |
| nenhum | Retorna os dados detalhados do último elemento clicado/selecionado pelo usuário. |
| nenhum | Lista o histórico de todos os elementos inspecionados durante a sessão atual. |
|
| Varre o DOM buscando elementos interativos por critérios textuais ou semânticos. |
|
| Destaca visualmente um elemento na página e valida se o seletor é único. |
|
| Gera o conteúdo completo de um arquivo |
| nenhum | Encerra o navegador e finaliza a sessão. |
🧪 Execução de Testes
Os testes cobrem unitariamente a geração de seletores, detecção de IDs dinâmicos, validação de schemas MCP e ciclo de vida Playwright:
uv run pytest -v📝 Exemplo de Arquivo .resource Gerado
*** Settings ***
Documentation Page Object Resource para LoginPage
Library Browser
*** Variables ***
${INPUT_USER} id=user-name
${INPUT_PASSWORD} id=password
${BTN_LOGIN} [data-testid="login-submit-btn"]
*** Keywords ***
Fill Input User
[Arguments] ${value}
[Documentation] Preenche o campo Input User com o valor informado
Fill Text ${INPUT_USER} ${value}
Fill Input Password
[Arguments] ${value}
[Documentation] Preenche o campo Input Password com o valor informado
Fill Text ${INPUT_PASSWORD} ${value}
Click Btn Login
[Documentation] Clica no botão Btn Login
Click ${BTN_LOGIN}Available Tools
7 toolsclose_browserA
Encerra a sessão do navegador e limpa os recursos.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of disclosing behavior. It does state the core behavioral effects: terminating the browser session and cleaning resources. It does not explicitly mention that the session is irreversibly closed or that any browser state is lost, which is a minor transparency gap.
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 short sentence with the primary action front-loaded and no filler. Every word contributes functional meaning.
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 parameterless tool with an output schema and an obvious lifecycle role, the description is nearly complete. It identifies the operation and resource clearly, but could add a brief note about it being the terminal browser step or the irreversible nature of closing the session.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero properties, so there are no parameters to document. Per the baseline for a zero-parameter tool, the description sufficiently conveys what the tool does without needing parameter-level detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action ('Encerra' = closes/ends) and a specific resource ('sessão do navegador' = browser session), plus the added effect of cleaning up resources. This makes its purpose unmistakable and clearly distinguishes it from siblings like launch_browser.
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 use is implied: close the browser session when it is no longer needed. However, the description does not explicitly state when to invoke it relative to other tools, such as 'use after completing browser automation,' nor does it mention alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
export_robot_resourceA
Gera um arquivo de recurso (.resource) completo para o Robot Framework baseado nos elementos inspecionados até o momento, contendo a seção *** Variables *** e *** Keywords *** (Page Object Pattern).
Args: page_name: Nome da página ou componente (ex: 'LoginPage', 'DashboardHeader'). library: Biblioteca alvo do Robot Framework ('Browser' para Playwright ou 'SeleniumLibrary'). include_children: Inclui o componente selecionado e seus descendentes. only_interactive: Limita descendentes a elementos interativos. max_depth: Profundidade máxima dos descendentes incluídos. output_path: Caminho opcional onde o arquivo .resource será gravado.
| Name | Required | Description | Default |
|---|---|---|---|
| library | No | Browser | |
| max_depth | No | ||
| page_name | Yes | ||
| output_path | No | ||
| include_children | No | ||
| only_interactive | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does explain the generated artifact, the Page Object Pattern structure, and that output_path controls where the file is written, but it does not mention overwrite behavior, return behavior when output_path is null, or any side effects beyond file creation.
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 core purpose and followed by a compact, structured Args list. There is no fluff, and every sentence contributes useful information.
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 purpose, prerequisite state (inspected elements), all parameters, and output destination. The presence of an output schema reduces the need to explain return values. Minor gaps remain around explicit edge cases such as overwriting existing files, but overall the description is sufficiently complete for an agent to call the tool 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?
Schema description coverage is 0%, but the description's Args block thoroughly explains all six parameters, including that library maps to Playwright or SeleniumLibrary, and that output_path is where the file will be written. This adds substantial meaning beyond the bare schema properties and fully compensates for the coverage gap.
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 generates a complete Robot Framework .resource file containing Variables and Keywords sections based on inspected elements. It is a specific verb+resource statement and is easily distinguishable from the sibling tools, which perform inspection, highlighting, and browser management.
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 'baseado nos elementos inspecionados até o momento' implies the tool should be used after elements have been inspected, but it never explicitly states when to prefer it over alternatives or when not to use it. Sibling tools are mostly different in function, yet no direct usage guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_selected_elementA
Recupera o último elemento selecionado/clicado pelo usuário no navegador. Retorna metadados completos (tag, id, classes, atributos, texto), além de locators ranqueados para Robot Framework (Browser Library e SeleniumLibrary) e keywords prontas.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral transparency burden. It transparently reports what is returned and makes the read-only, stateful nature of the operation clear. It does not disclose edge cases like what happens when no element has been selected or whether the returned data may be stale.
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 dense, well-organized sentences: the first states the action, the second lists the returned artifacts. There is no filler, repetition, or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless read-only tool with an output schema, the description sufficiently covers purpose and return values. It leaves only the no-selection edge case and prerequisite user interaction implicit, which prevents a perfect score.
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 and schema coverage is 100%, so there is nothing for the description to clarify. The baseline 4 applies because no parameter documentation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the operation: it retrieves the last element the user selected or clicked in the browser. It also specifies the output content (metadata, locators, keywords), making the tool's purpose easy to grasp. However, it does not explicitly distinguish itself from siblings like get_selection_history or scan_elements.
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 use is implicitly clear: call this tool when you need the last user-selected element and its Robot Framework locators. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as get_selection_history, so the guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_selection_historyA
Retorna o histórico de todos os elementos selecionados/inspecionados na sessão atual.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It clarifies the session-scoped nature of the returned history and what the history contains, but it does not mention ordering, limits, or whether the history is cleared or cumulative in any particular way.
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, front-loaded sentence that directly states the return value and its scope. Every word earns its place, and there is no redundant or vague 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?
For a zero-parameter read tool with an output schema, the description adequately covers what the tool returns and its session boundary. It could be slightly more complete by noting that this is a read-only retrieval operation, but nothing essential is missing for calling 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 tool has zero parameters, so there is no parameter ambiguity to resolve. Per the baseline for tools with no parameters, a score of 4 is appropriate even though the description provides no additional parameter-level detail.
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 a specific verb ('returns') and resource ('history of all selected/inspected elements in the current session'), making the tool's function immediately clear. It also distinguishes itself from the sibling get_selected_element by indicating that this tool returns history rather than the current single selection.
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 that the tool should be used when a list of all previously selected/inspected elements in the session is needed, but it gives no explicit guidance about when to choose this over get_selected_element or scan_elements. No alternatives or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
highlight_elementA
Destaca visualmente um elemento na página do navegador através de um seletor e valida se ele é único.
Args: selector: Seletor CSS ou ID a validar e destacar (ex: '#login-btn' ou '[data-testid="submit"]').
| Name | Required | Description | Default |
|---|---|---|---|
| selector | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden and does disclose the main effect: visual highlighting plus uniqueness validation. It does not disclose what happens when the selector is not unique, whether the page must already be open, or what side effects occur beyond the highlight.
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 short, front-loaded with the core purpose, and the parameter explanation is compact with helpful examples. Every sentence contributes information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main input and action, and an output schema exists to document return values. However, it omits behavior for edge cases such as multiple matches, no match, or invalid selector format, and it does not state any browser-session prerequisite.
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?
Although the schema has no property description, the tool description compensates by explaining the selector parameter as a CSS selector or ID and gives concrete examples like '#login-btn'. This adds meaningful semantics beyond the raw schema field name.
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 a specific action ('Destaca visualmente') and resource ('elemento na página do navegador'), and adds a secondary behavior of validating uniqueness. It is clearly distinct from siblings like get_selected_element, though it does not explicitly name or differentiate them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The purpose itself implies the tool is for visually highlighting and validating a unique element on the page, giving clear context. However, there is no explicit guidance about when to choose this tool over siblings such as scan_elements or get_selected_element, nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
launch_browserA
Abre um navegador visível (headful por padrão) na URL informada e injeta o inspetor do DOM Explorer.
Args: url: O endereço web para navegar (ex: 'https://exemplo.com.br' ou 'localhost:3000'). headless: Se True, roda em segundo plano. Padrão False (abre janela visível para o usuário interagir). browser_type: Tipo de navegador ('chromium', 'firefox', 'webkit'). Padrão 'chromium'.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| headless | No | ||
| browser_type | No | chromium |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose key behaviors: default headful mode, headless option, and DOM Explorer inspector injection. It does not mention side effects such as browser lifecycle, resource usage, or whether it establishes an interactive session, which would add further transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded, with a one-sentence purpose followed by a structured Args block. Every sentence is useful, though the formatting is slightly loose with inline 'Args:' rather than a formal structure.
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 3-parameter tool with one required parameter and an output schema, the description covers the core purpose, parameter semantics, and default behavior. It does not explain the DOM Explorer inspector's role or integrate with sibling workflows, but those are not essential for a correct call.
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 0%, but the description fully compensates by explaining all three parameters: url with example, headless with default and behavior, and browser_type with enumerated options and default. This adds meaning beyond the schema's bare property definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: opens a visible browser at the given URL and injects the DOM Explorer inspector. It uses specific verbs and resources, and the action is distinct from siblings like scan_elements and close_browser. However, it does not explicitly call out sibling alternatives, so it doesn't fully earn 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 implies usage context through details like 'headful by default' and 'opens a visible window for the user to interact with,' suggesting when this is appropriate. However, there is no explicit guidance on when to avoid this tool or use an alternative, leaving selection largely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_elementsA
Varre o DOM da página atual procurando elementos interativos por critérios textuais ou semânticos. Útil para mapear formulários ou botões sem necessidade de clicar em cada um manualmente.
Args: selector: Seletor CSS específico para buscar (ex: 'form.login input'). tag: Filtrar por tag HTML (ex: 'button', 'input', 'select', 'a'). role: Filtrar por ARIA role (ex: 'button', 'checkbox', 'tab'). text: Filtrar por texto visível parcial (case-insensitive, ex: 'Salvar' ou 'Entrar'). limit: Quantidade máxima de elementos a retornar (padrão 25).
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | ||
| role | No | ||
| text | No | ||
| limit | No | ||
| selector | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Sem anotações, a descrição assume o peso: declara que a operação varre o DOM da página atual e que não requer cliques, sugerindo leitura sem efeitos colaterais. Não detalha possíveis efeitos no histórico de seleção/estado do browser, mas o comportamento principal é transparente.
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?
Texto enxuto e bem estruturado: propósito na primeira frase, caso de uso em uma segunda e lista formatada de argumentos. Cada frase agrega valor e a informação crítica está no início.
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?
Para uma ferramenta de varredura com cinco parâmetros opcionais e output schema presente, a descrição cobre propósito, parâmetros e cenário de uso. Fica implícito como os filtros se combinam (AND entre critérios) e eventuais limitações do DOM varrido, mas nada bloqueia a invocação correta.
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?
A cobertura do schema é 0%, mas a seção 'Args' compensa integralmente: cada parâmetro ganha significado adicional (exemplos de selector, tags e roles, correspondência parcial case-insensitive para text, default de limit). Valor muito além dos simples tipos/valores padrão do 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?
A descrição começa com verbo específico e recurso: 'Varre o DOM da página atual procurando elementos interativos'. Diferencia-se claramente dos irmãos ao focar em mapeamento por critérios textuais/semânticos sem clicar, o que a distingue de highlight_element e get_selected_element.
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?
Indica explicitamente um cenário de uso: 'Útil para mapear formulários ou botões sem necessidade de clicar em cada um manualmente'. Não nomeia alternativas nem exceções, mas nenhum irmão é um substituto direto, então o contexto é suficiente.
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
v0.1.0- First observed
close_browser - First observed
export_robot_resource - First observed
get_selected_element - First observed
get_selection_history - First observed
highlight_element - First observed
launch_browser - First observed
scan_elements
TDQS
Scored across 7 tools
Most tools target distinct actions: browser lifecycle, element selection retrieval, scanning, highlighting, and export. The main potential confusion is between get_selected_element and get_selection_history, but the current-element vs history distinction is clear enough.
All tool names follow a consistent verb_noun pattern in English (get_selected_element, launch_browser, scan_elements, highlight_element, export_robot_resource, close_browser). No mixed casing or stylistic deviations.
Seven tools is a well-scoped size for a DOM exploration and Robot Framework export server. Each tool contributes to a clear workflow without redundancy or bloat.
The set covers browser lifecycle, element discovery/inspection, highlighting, history, and resource file generation. Minor gaps include no navigation/refresh tool and no direct single-element fetch by selector, but these can be worked around.
Maintenance
Related MCP Connectors
Playwright selector risk checks with healing suggestions and receipts.
Browser-based QA for AI-built software. Test pages with real browsers via agents.
Approved test intent, reviewed Playwright automation and run evidence, inside your editor.
1AI QA tester — real browsers scan sites for bugs, SEO, perf, and accessibility issues via chat.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI assistants to inspect, debug, and test web pages using Playwright. Provides comprehensive DOM inspection, visibility debugging, layout validation, and element finding capabilities in real browser environments.3472 npm5MIT
- AlicenseAqualityDmaintenanceGenerates intelligent Playwright locators with reliability rankings, creates Page Object Models, and runs test automation scripts directly from your IDE or AI assistant.56 npm1MIT
- AlicenseNot gradedqualityDmaintenanceEnables generating Robot Framework test cases with SeleniumLibrary, creating page object models, and performing performance monitoring through natural language.6 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to drive Robot Framework through natural language, discovering keywords, running live test steps across web, mobile, API, database, and desktop targets, and generating clean .robot test suites from plain-English instructions.Apache 2.0