Skip to main content
Glama
bob-reis

mcp-brasil

by bob-reis

mcp-brasil

MCP Server para 36 fontes públicas brasileiras e 1 agente

License: MIT

245 tools · 58 resources · 48 prompts

Conecte AI agents (Claude, GPT, Copilot, etc.) a dados governamentais do Brasil — economia, legislação, transparência, judiciário, eleições, meio ambiente, saúde e mais.

33 fontes não requerem chave · 3 usam chaves de API · 1 fonte adicional depende de token Meta

Quick Start · Origem e alterações · Fontes de dados · Casos de Uso · Documentação · Desenvolvimento


Features

  • 245 tools em 37 features ativas — economia, legislativo, transparência, controle externo, judiciário, eleitoral, ambiental, saúde, compras públicas, aviação, mercado de capitais, sanções/PEPs, oceanografia e redação oficial

  • Cross-referencing com planejar_consulta — cria planos de execução combinando múltiplas APIs (ex: gastos de um deputado + votações + proposições)

  • Execução em lote com executar_lote — dispara consultas em paralelo numa única chamada

  • Smart discovery — BM25 search transform filtra o catálogo de tools para só mostrar as relevantes ao contexto

  • Auto-registry — adicionar uma feature é criar uma pasta; zero configuração manual

  • Async everywhere — httpx async + Pydantic v2 + rate limiting com backoff

Related MCP server: mcp-brasil

Origem e alterações

Este projeto foi baixado a partir de, e hoje deve ser lido como uma evolução inspirada por, jxnxts/mcp-brasil. A base original serviu como ponto de partida conceitual para expor APIs públicas brasileiras via MCP/FastMCP, mas esta árvore foi bastante expandida e reorganizada.

Principais alterações feitas nesta versão:

  • ampliação do catálogo para 37 features ativas, com 241 tools de features mais 4 meta-tools (listar_features, recomendar_tools, planejar_consulta, executar_lote);

  • inclusão de novas fontes como ANAC, ANS, BNDES, CVM, IBAMA, SICONFI, OpenSanctions, Dados Abertos MT, IOMAT-MT e mais TCEs;

  • organização por feature com FeatureMeta, server.py, cliente HTTP, schemas e tools isolados;

  • auto-discovery em mcp_brasil.data e mcp_brasil.agentes, reduzindo configuração manual ao adicionar uma fonte;

  • meta-tools para descoberta, planejamento de consultas complexas e execução em lote;

  • suporte a BM25/code-mode para reduzir ruído em clientes que não lidam bem com centenas de tools;

  • agente redator para documentos oficiais, separado das fontes de dados.

Quick Start

Instalar

pip install mcp-brasil
uv add mcp-brasil

Claude Desktop

Adicione ao claude_desktop_config.json:

{
  "mcpServers": {
    "mcp-brasil": {
      "command": "uvx",
      "args": ["--from", "mcp-brasil", "python", "-m", "mcp_brasil.server"],
      "env": {
        "TRANSPARENCIA_API_KEY": "sua-chave-aqui",
        "DATAJUD_API_KEY": "sua-chave-aqui",
        "OPENSANCTIONS_API_KEY": "sua-chave-aqui",
        "META_ACCESS_TOKEN": "seu-token-aqui"
      }
    }
  }
}

Sem uma chave configurada, a feature correspondente é ignorada no auto-registry; as demais fontes continuam funcionando normalmente.

VS Code / Cursor

Crie .vscode/mcp.json na raiz do projeto:

{
  "servers": {
    "mcp-brasil": {
      "command": "uvx",
      "args": ["--from", "mcp-brasil", "python", "-m", "mcp_brasil.server"],
      "env": {
        "TRANSPARENCIA_API_KEY": "sua-chave-aqui",
        "DATAJUD_API_KEY": "sua-chave-aqui",
        "OPENSANCTIONS_API_KEY": "sua-chave-aqui",
        "META_ACCESS_TOKEN": "seu-token-aqui"
      }
    }
  }
}

Claude Code

claude mcp add mcp-brasil -- uvx --from mcp-brasil python -m mcp_brasil.server

HTTP (outros clientes)

fastmcp run mcp_brasil.server:mcp --transport http --port 8000
# Server disponível em http://localhost:8000/mcp

Exemplos

Conecte o server e faça perguntas em linguagem natural:

Legislativo: "Quais projetos de lei sobre inteligência artificial tramitaram na Câmara em 2024? Quem foram os autores?"

Econômico: "Qual a tendência da taxa Selic nos últimos 12 meses? Compare com a inflação (IPCA) no mesmo período."

Transparência: "Quais os 10 maiores contratos do governo federal em 2024? Quem são os fornecedores?"

Cross-reference: "Compare os gastos per capita com saúde em São Paulo e Minas Gerais cruzando dados do TCE-SP e IBGE."

Judiciário: "Busque processos sobre licitação irregular no TCU. Quais foram as penalidades aplicadas?"

Eleitoral: "Quais os maiores doadores da campanha do candidato X? Qual o total arrecadado?"

Fontes de dados

Categoria

Feature

API

Tools

Econômico

ibge

IBGE — estados, municípios, nomes, agregados estatísticos

9

bacen

Banco Central — Selic, IPCA, câmbio, PIB e +190 séries

10

bndes

BNDES — operações de financiamento não-automáticas

1

cvm

CVM — companhias abertas, fundos e processos sancionadores

3

siconfi

SICONFI/Tesouro — RREO, RGF e contas anuais

3

Legislativo

camara

Câmara dos Deputados — deputados, proposições, votações, despesas

11

senado

Senado Federal — senadores, matérias, votações, comissões

26

Transparência / Fiscal

transparencia

Portal da Transparência — contratos, despesas, servidores, sanções

19

tcu

Tribunal de Contas da União — acórdãos, licitantes inidôneos

8

tce_sp

TCE-SP — despesas e receitas de 645 municípios paulistas

3

tce_rj

TCE-RJ — licitações, contratos, obras, penalidades

7

tce_rs

TCE-RS — educação, saúde, gestão fiscal (LRF)

5

tce_sc

TCE-SC — municípios e unidades gestoras

2

tce_pe

TCE-PE — licitações, contratos, despesas, fornecedores

5

tce_ce

TCE-CE — licitações, contratos, empenhos

4

tce_rn

TCE-RN — jurisdicionados, licitações, contratos

5

tce_pi

TCE-PI — prefeituras, despesas, receitas

5

tce_to

TCE-TO — processos, pautas de sessões

3

dadosabertos_mt

Dados Abertos MT — catálogo CKAN estadual

5

Judiciário

datajud

DataJud/CNJ — processos judiciais, movimentações

7

jurisprudencia

STF, STJ e TST — acórdãos, súmulas, decisões

6

Eleitoral

tse

TSE — eleições, candidatos, prestação de contas

15

anuncios_eleitorais

Biblioteca de Anúncios da Meta — anúncios políticos e eleitorais (requer token)

4

Ambiental

inpe

INPE — focos de queimadas e desmatamento

4

ana

ANA — estações hidrológicas, telemetria, reservatórios

3

ibama

IBAMA — áreas embargadas e autos de infração

3

Saúde

saude

CNES/DataSUS — estabelecimentos, profissionais, leitos

4

ans

ANS — operadoras de planos de saúde

1

Aviação

anac

ANAC/RAB — aeronaves registradas no Brasil

1

Oceanografia

tabua_mares

Tábua de Marés — previsão de marés para portos do litoral brasileiro

7

Compras Públicas

compras

PNCP + Compras.gov.br — licitações, contratos, fornecedores, CATMAT, CATSER, pregões e pesquisa de preços

13

Utilidades

brasilapi

BrasilAPI — CEP, CNPJ, DDD, bancos, câmbio, FIPE, PIX

16

dados_abertos

Dados Abertos (dados.gov.br) — catálogo de datasets

4

diario_oficial

Querido Diário — diários oficiais de 5.000+ cidades

4

iomat_mt

Diário Oficial de MT/IOMAT — publicações e edições

5

transferegov

TransfereGov — emendas parlamentares PIX

5

Compliance

opensanctions

OpenSanctions — sanções internacionais e PEPs

4

Agentes IA

redator

Redator Oficial — ofício, despacho, portaria, parecer, nota técnica

5

Além das tools das features, o server raiz expõe 4 meta-tools: listar_features, recomendar_tools, planejar_consulta e executar_lote.

Chaves de API

API

Obrigatória?

Como obter

Portal da Transparência

Sim para ativar a feature

Cadastro gratuito

DataJud/CNJ

Sim para ativar a feature

Cadastro gratuito

OpenSanctions

Sim para ativar a feature

API keys

Biblioteca de Anúncios da Meta

Sim para ativar a feature anuncios_eleitorais

Meta for Developers

Dados.gov.br

Opcional (melhora rate limits)

Portal Dados Abertos

Todas as outras fontes

Nenhuma chave

—

Configure via variáveis de ambiente ou .env:

TRANSPARENCIA_API_KEY=sua-chave
DATAJUD_API_KEY=sua-chave
OPENSANCTIONS_API_KEY=sua-chave
META_ACCESS_TOKEN=seu-token
DADOS_GOV_BR_API_TOKEN=seu-token  # opcional

Configuração

Variável

Default

Descrição

TRANSPARENCIA_API_KEY

—

Chave do Portal da Transparência

DATAJUD_API_KEY

—

Chave do DataJud/CNJ

OPENSANCTIONS_API_KEY

—

Chave da API OpenSanctions

META_ACCESS_TOKEN

—

Token da Meta Graph API para anúncios eleitorais

DADOS_GOV_BR_API_TOKEN

—

Token bearer do dados.gov.br (opcional)

MCP_BRASIL_TOOL_SEARCH

bm25

Modo de discovery: bm25, code_mode ou none

MCP_BRASIL_HTTP_TIMEOUT

30.0

Timeout HTTP em segundos

MCP_BRASIL_HTTP_MAX_RETRIES

3

Máximo de retentativas HTTP

LLM local (Ollama)

As meta-tools recomendar_tools e planejar_consulta usam um LLM para entender intenção e montar planos de execução. Por padrão esperam ANTHROPIC_API_KEY, mas podem rodar inteiramente local via Ollama:

LLM_PROVIDER=ollama          # "ollama" ou "anthropic" (default: anthropic)
OLLAMA_BASE_URL=http://localhost:11434  # URL do servidor Ollama
OLLAMA_MODEL=qwen3.5:cloud   # qualquer modelo disponível no Ollama

Modelos recomendados: qwen3.5:cloud, qwen3-coder:480b-cloud, llama3.1:8b.
Quando LLM_PROVIDER=anthropic, configure ANTHROPIC_API_KEY com uma chave em console.anthropic.com.

Variável

Default

Descrição

LLM_PROVIDER

anthropic

Provider LLM: ollama ou anthropic

OLLAMA_BASE_URL

http://localhost:11434

URL base do servidor Ollama

OLLAMA_MODEL

qwen3.5:cloud

Modelo Ollama a usar

ANTHROPIC_API_KEY

—

Chave Anthropic (necessária quando LLM_PROVIDER=anthropic)

Documentação

Página

Descrição

Quick Start

Instalação e configuração em 2 minutos

Arquitetura

Como o projeto funciona por dentro

Catálogo de Features

Catálogo de features e tools disponíveis

Smart Tools

Meta-tools: planner, batch, discovery

Adicionando Features

Guia para contribuir com novas APIs

Configuração

Variáveis de ambiente e opções

Desenvolvimento

Setup de dev, testes, lint, CI

Casos de Uso

Exemplos detalhados de como usar o mcp-brasil em diferentes contextos profissionais:

Caso de Uso

Descrição

APIs Combinadas

Panorama Econômico

Dashboard econômico com Selic, IPCA, câmbio, PIB

Bacen, IBGE, Transparência

Fiscalização Municipal

Onde vai o dinheiro da sua cidade — 9 TCEs cruzados

TCEs, PNCP, TransfereGov, IBGE

Análise Legislativa

Ciclo completo de um PL: Câmara → Senado → Diário Oficial → STF

Câmara, Senado, Diário Oficial, DataJud

Cientista Político

Fidelidade partidária, coalizões, emendas como poder

Câmara, Senado, TSE, Transparência

Economista

Séries temporais, política fiscal, câmbio, crédito

Bacen (40K+ séries), IBGE

Jornalista Investigativo

Rastrear emendas, licitações dirigidas, fornecedores suspeitos

Transparência, TCEs, TCU, PNCP, TSE

Jornalista — Matérias

Produção de matérias data-driven com dados verificáveis

Bacen, IBGE, Câmara, INPE, TSE

Relatório Parlamentar

Votação + emendas + despesas + financiamento de um parlamentar

Câmara, Senado, TSE, TransfereGov

Políticas Públicas

Avaliar impacto: recursos investidos vs. resultados

TCEs, IBGE, CNES, Transparência, INPE

Redator Oficial

Gerar ofícios, pareceres e notas técnicas com dados reais

Redator + Bacen, Transparência, TCU

Desenvolvimento

git clone https://github.com/jxnxts/mcp-brasil.git
cd mcp-brasil
make dev              # Instalar dependências (prod + dev)
make test             # Rodar todos os testes
make test-feature F=ibge  # Testes de uma feature
make lint             # Lint + format check
make ruff             # Auto-fix lint + format
make types            # mypy strict
make ci               # lint + types + test
make run              # Server stdio
make serve            # Server HTTP :8000
make inspect          # Listar tools/resources/prompts

Arquitetura

O projeto usa Package by Feature com Auto-Registry — cada feature é uma pasta auto-contida:

src/mcp_brasil/
├── server.py              # Auto-registry (nunca editado manualmente)
├── _shared/               # Utilitários compartilhados
├── data/                  # Features de consulta a APIs/fontes de dados
│   ├── ibge/
│   │   ├── __init__.py    # FEATURE_META
│   │   ├── server.py      # FastMCP instance
│   │   ├── tools.py       # Lógica das tools
│   │   ├── client.py      # HTTP async
│   │   ├── schemas.py     # Pydantic models
│   │   └── constants.py   # URLs, códigos
│   ├── bacen/
│   └── ...
└── agentes/               # Features de agentes inteligentes
    └── redator/

Para adicionar uma nova feature, basta criar o diretório seguindo a convenção — o registry descobre automaticamente.

Contribuindo

  1. Fork o repositório

  2. Crie uma feature em src/mcp_brasil/data/{feature}/ ou agentes/{feature}/

  3. Exporte FEATURE_META no __init__.py e mcp: FastMCP no server.py

  4. Adicione testes em tests/data/{feature}/

  5. Rode make ci e abra um PR

Disclaimer

Este projeto integra um número significativo de APIs governamentais brasileiras, muitas com documentação inconsistente ou incompleta. Embora todo esforço tenha sido feito para garantir precisão, alguns endpoints podem retornar resultados inesperados ou ter cobertura parcial de parâmetros.

Este é um projeto open-source da comunidade — se encontrar algo quebrado ou que possa ser melhorado, abra uma issue ou envie um PR. O objetivo é tornar dados públicos brasileiros acessíveis via IA, juntos.

Todos os dados vêm de APIs oficiais do governo brasileiro — o server não gera, modifica ou editorializa nenhum dado.

Licença

MIT

Available Tools

6 tools
call_toolA

Call a tool by name with the given arguments.

Use this to execute tools discovered via search_tools.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYesThe name of the tool to call
argumentsNoArguments to pass to the tool

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden for behavioral disclosure. It merely restates the schema without describing side effects, return values, error conditions, or the fact that calling arbitrary tools may have destructive consequences. This is a significant 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is exactly two sentences, front-loaded with the primary action and followed by a usage hint. Every word earns its place, with no redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple, but with no output schema and no annotations, the description could have mentioned that the tool returns the called tool's output or that invalid names will error. The core functionality is clear, but some behavioral expectations are missing, so it is minimally viable rather than complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with both parameters described. The description adds little beyond the schema, repeating 'by name with the given arguments' without explaining how arguments map to the called tool's parameters. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action: 'Call a tool by name with the given arguments,' which specifies the verb and resource. It also differentiates from search_tools by noting the tool is for executing discovered tools, but it does not explicitly distinguish from the sibling executar_lote, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage context: 'Use this to execute tools discovered via search_tools.' This tells the agent when the tool is appropriate, but it does not mention exclusions or alternatives, so it is not a full 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

executar_loteA

Executa múltiplas tools em uma única chamada, em paralelo.

Use esta tool para evitar chamadas sequenciais quando precisar de dados de várias fontes ou de vários anos/parâmetros ao mesmo tempo.

Cada consulta deve ter o nome completo da tool (com namespace, ex: "camara_buscar_proposicao") e seus argumentos.

Args: consultas: Lista de consultas. Cada item é um objeto com: - "tool": nome completo da tool (ex: "camara_despesas_deputado") - "args": objeto com os argumentos da tool Exemplo: [ {"tool": "camara_despesas_deputado", "args": {"deputado_id": 204554, "ano": 2024}}, {"tool": "camara_despesas_deputado", "args": {"deputado_id": 204554, "ano": 2023}} ]

ParametersJSON Schema
NameRequiredDescriptionDefault
consultasYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.1/5.0
Behavior2/5

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 only mentions parallel execution and the need for full tool names, but does not disclose failure semantics, partial failure behavior, side effects of executing multiple tools, permissions, or result format. This is a significant gap for a batch execution tool that may invoke arbitrary tools with potential side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with the core verb and purpose. Each section (when to use, required format, example) earns its place, and the example improves clarity without excessive verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the essential invocation details and example, and the presence of an output schema reduces the need to explain return values. However, it omits constraints like maximum batch size or behavior on individual tool failures, which are relevant for safe and effective use of a batch execution tool. Overall it is quite complete for typical use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema for 'consultas' is essentially opaque (no property descriptions), so the description fully compensates by defining the exact structure of each item (required 'tool' and 'args' keys) and providing a clear example. This adds substantial meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states 'Executa múltiplas tools em uma única chamada, em paralelo', clearly identifying the verb, resource, and parallel execution mode. It distinguishes itself from siblings like 'call_tool' by emphasizing batch execution of multiple tools in one call.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says when to use: 'para evitar chamadas sequenciais quando precisar de dados de várias fontes ou de vários anos/parâmetros ao mesmo tempo'. It does not explicitly name alternatives (e.g., 'call_tool') for single calls, but the usage context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

listar_featuresA

Lista todas as features (APIs) disponíveis no mcp-brasil.

Use esta tool para saber quais APIs governamentais estão conectadas e quais tools cada uma oferece.

Returns: Resumo das features ativas com descrição e status de autenticação.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of disclosing behavior. It clearly indicates a read-only listing action and describes the returned content ('Resumo das features ativas com descrição e status de autenticação'), which is sufficient for a simple, non-mutating tool. It does not mention side effects because there are none.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured, with a clear opening statement, an explicit usage sentence, and a separate 'Returns:' section. Every sentence contributes useful information, and there is no waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and a simple listing function, the description is complete. It explains what is listed, why to use it, and what is returned. The presence of an output schema means the description does not need to detail return values further.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description does not need to elaborate on parameter semantics. The baseline for 0 params is 4, and no further information is required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Lista todas as features (APIs) disponíveis no mcp-brasil' using a specific verb and resource. It also distinguishes itself from siblings by explaining that it reveals which government APIs are connected and which tools each offers, setting it apart from 'listar_datasets_disponiveis' and 'search_tools'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit context is provided in 'Use esta tool para saber quais APIs governamentais estão conectadas e quais tools cada uma oferece.' This tells the agent when to use the tool, though it does not explicitly mention alternatives or situations to avoid, preventing a score of 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

planejar_consultaA

Cria um plano de execução para consultas complexas.

Analisa a pergunta, identifica quais tools usar, em que ordem, e quais etapas dependem de outras. Útil para consultas que precisam de múltiplas chamadas combinadas.

Args: query: Pergunta em linguagem natural (ex: "compare os gastos do deputado X com a média").

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It explains the tool's behavior in detail: it analyzes the question, identifies tools, order, and dependencies, which implies it only creates a plan and does not execute it. This is transparent and non-misleading.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded, with a one-sentence purpose, a brief but informative explanation, and an Args section. Every sentence adds value, and the example is helpful without verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the single parameter, presence of an output schema, and no annotations, the description covers the purpose, usage context, parameter meaning, and provides an example. It is sufficient for an agent to select and invoke this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only declares 'query' as a string with no description. The description compensates by explaining it as a natural language question and providing a concrete example, which fully disambiguates the parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('cria um plano de execução') for complex queries, and, further details explain it analyzes the question and determines tool order and dependencies. This clearly distinguishes it from sibling tools by emphasizing ordering and dependency analysis beyond mere tool recommendation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly states it is useful for queries that need multiple combined calls, which tells an agent when to use it. However, it does not mention when not to use it or explicitly compare it to alternatives like recomendar_tools, so it lacks exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

recomendar_toolsA

Recomenda tools relevantes a partir de uma pergunta em linguagem natural.

Usa IA para entender sua intenção e sugerir as tools mais adequadas do mcp-brasil, explicando quando e como usar cada uma.

Args: query: Pergunta ou descrição do que você precisa (ex: "quero dados sobre gastos do governo federal").

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden. It discloses that the tool uses AI to understand intent and suggests the most adequate tools from mcp-brasil, which implies a non-destructive read-only operation. However, it does not describe the output structure (though an output schema exists) or any limitations of the AI-based recommendation process.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured. It front-loads the core purpose in the first sentence, adds a brief clarifying sentence about the AI mechanism, and then presents the argument documentation in a clean, scannable format. No word is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter recommender, the description adequately covers the main functionality, the input format, and the source of recommendations (mcp-brasil). The presence of an output schema reduces the need to document return values. It could explicitly differentiate from 'search_tools', but overall it is sufficiently complete for an agent to select and invoke it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides zero description for the single 'query' parameter, but the description compensates with an 'Args' section that explains the parameter meaning and gives a concrete example: 'quero dados sobre gastos do governo federal'. This fully covers the parameter's semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Recomenda tools relevantes a partir de uma pergunta em linguagem natural' (Recommends relevant tools from a natural language question). It uses a specific verb ('recomenda') and resource ('tools'), and distinguishes itself from siblings like 'search_tools' by emphasizing AI-based intent comprehension and providing explanations for each recommendation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any guidance on when to use this tool versus alternatives such as 'search_tools' or 'listar_features'. It mentions that the tool will explain 'quando e como usar cada uma' (when and how to use each recommended tool), but this refers to the output content, not to the circumstances under which an agent should invoke this tool itself.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_toolsA

Search for tools using natural language.

Returns matching tool definitions ranked by relevance, in the same format as list_tools.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesNatural language query to search for tools

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It states that it returns matching tool definitions ranked by relevance, which is a behavioral trait. It also mentions the format is same as list_tools, which is useful. However, it doesn't disclose any side effects, rate limits, or other behavioral details. Given the tool is a search operation, this is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, two sentences, and front-loaded with the purpose. Every sentence adds value: the first states what it does, the second clarifies the return format. No waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with one parameter and an output schema. The description explains the return format (same as list_tools) and ranking by relevance. Given the simplicity and the presence of an output schema, the description is complete enough. It could mention that it's a read-only operation, but that's not critical.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the single parameter 'query' as a natural language query. The description adds no additional meaning beyond that. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: searching for tools using natural language. It specifies the action (search) and the resource (tools), and distinguishes it from siblings like list_tools by mentioning the return format. However, it doesn't explicitly differentiate from other sibling tools like call_tool, but the purpose is clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: when you need to find tools by natural language query. It mentions the return format is same as list_tools, which gives some context. However, it doesn't explicitly state when to use this vs alternatives, nor does it provide exclusions or alternative tool references. The guidance is minimal but not misleading.

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.

  1. 6 tool updatesv0.5.0
    • First observedcall_tool
    • First observedexecutar_lote
    • First observedlistar_features
    • First observedplanejar_consulta
    • First observedrecomendar_tools
    • First observedsearch_tools

TDQS

A3.7/5.0

Scored across 6 tools

Disambiguation3/5

Several tools overlap in discovery and planning: recomendar_tools, planejar_consulta, and search_tools all take natural-language queries and return tool suggestions, while listar_features also enumerates available tools. They differ in output format, but an agent may struggle to pick the right one.

Naming Consistency3/5

All names follow a verb_noun snake_case pattern, but the language is inconsistent: four Portuguese names and two English names, with recomendar_tools mixing Portuguese and English within one name. This mixed-language naming reduces predictability.

Tool Count4/5

Six tools is a reasonable number for a meta-orchestration server that wraps many underlying data APIs. Each tool has a distinct role and the count falls comfortably within the well-scoped 3-15 range.

Completeness4/5

The tool surface covers discovery, search, recommendation, planning, batch execution, and single execution. A minor gap is the absence of an explicit full-tool-list command like standard list_tools, but agents can work around with listar_features and search_tools.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    C
    maintenance
    An MCP server that provides real-time access to Brazilian agricultural data, including commodity prices, crop estimates, climate information, and deforestation rates. It integrates data from 19 public sources like CEPEA, CONAB, and IBGE to enable LLMs to analyze the Brazilian agribusiness sector.
    10
    28
    MIT
  • A
    license
    A
    quality
    C
    maintenance
    An MCP server that connects AI agents to over 200 tools across 27 Brazilian public APIs, covering economic, legislative, transparency, and judicial data. It enables users to query and cross-reference extensive government datasets from sources like IBGE, the Central Bank, and the Brazilian Congress.
    7
    1,807
    MIT
  • A
    license
    A
    quality
    D
    maintenance
    MCP server for Portuguese Parliament open data, enabling AI agents to access legislative initiatives, deputies, plenary votes, petitions, and parliamentary committees.
    12
    10 npm
    MIT
  • A
    license
    Not graded
    quality
    D
    maintenance
    This MCP server provides AI-optimized access to Brazil's largest open data platform, Base dos Dados, enabling dataset search and direct BigQuery SQL execution for Brazilian public datasets.
    1
    MIT