mcp-brasil
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., "@mcp-brasilGastos per capita saúde SP vs MG"
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.
mcp-brasil
MCP Server para 36 fontes públicas brasileiras e 1 agente
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 chamadaSmart 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.dataemcp_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
redatorpara documentos oficiais, separado das fontes de dados.
Quick Start
Instalar
pip install mcp-brasiluv add mcp-brasilClaude 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.serverHTTP (outros clientes)
fastmcp run mcp_brasil.server:mcp --transport http --port 8000
# Server disponível em http://localhost:8000/mcpExemplos
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 — estados, municípios, nomes, agregados estatísticos | 9 |
| Banco Central — Selic, IPCA, câmbio, PIB e +190 séries | 10 | |
| BNDES — operações de financiamento não-automáticas | 1 | |
| CVM — companhias abertas, fundos e processos sancionadores | 3 | |
| SICONFI/Tesouro — RREO, RGF e contas anuais | 3 | |
Legislativo |
| Câmara dos Deputados — deputados, proposições, votações, despesas | 11 |
| Senado Federal — senadores, matérias, votações, comissões | 26 | |
Transparência / Fiscal |
| Portal da Transparência — contratos, despesas, servidores, sanções | 19 |
| Tribunal de Contas da União — acórdãos, licitantes inidôneos | 8 | |
| TCE-SP — despesas e receitas de 645 municípios paulistas | 3 | |
| TCE-RJ — licitações, contratos, obras, penalidades | 7 | |
| TCE-RS — educação, saúde, gestão fiscal (LRF) | 5 | |
| TCE-SC — municípios e unidades gestoras | 2 | |
| TCE-PE — licitações, contratos, despesas, fornecedores | 5 | |
| TCE-CE — licitações, contratos, empenhos | 4 | |
| TCE-RN — jurisdicionados, licitações, contratos | 5 | |
| TCE-PI — prefeituras, despesas, receitas | 5 | |
| TCE-TO — processos, pautas de sessões | 3 | |
| Dados Abertos MT — catálogo CKAN estadual | 5 | |
Judiciário |
| DataJud/CNJ — processos judiciais, movimentações | 7 |
| STF, STJ e TST — acórdãos, súmulas, decisões | 6 | |
Eleitoral |
| TSE — eleições, candidatos, prestação de contas | 15 |
| Biblioteca de Anúncios da Meta — anúncios políticos e eleitorais (requer token) | 4 | |
Ambiental |
| INPE — focos de queimadas e desmatamento | 4 |
| ANA — estações hidrológicas, telemetria, reservatórios | 3 | |
| IBAMA — áreas embargadas e autos de infração | 3 | |
Saúde |
| CNES/DataSUS — estabelecimentos, profissionais, leitos | 4 |
| ANS — operadoras de planos de saúde | 1 | |
Aviação |
| ANAC/RAB — aeronaves registradas no Brasil | 1 |
Oceanografia |
| Tábua de Marés — previsão de marés para portos do litoral brasileiro | 7 |
Compras Públicas |
| PNCP + Compras.gov.br — licitações, contratos, fornecedores, CATMAT, CATSER, pregões e pesquisa de preços | 13 |
Utilidades |
| BrasilAPI — CEP, CNPJ, DDD, bancos, câmbio, FIPE, PIX | 16 |
| Dados Abertos (dados.gov.br) — catálogo de datasets | 4 | |
| Querido Diário — diários oficiais de 5.000+ cidades | 4 | |
| Diário Oficial de MT/IOMAT — publicações e edições | 5 | |
| TransfereGov — emendas parlamentares PIX | 5 | |
Compliance |
| OpenSanctions — sanções internacionais e PEPs | 4 |
Agentes IA |
| 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 | |
DataJud/CNJ | Sim para ativar a feature | |
OpenSanctions | Sim para ativar a feature | |
Biblioteca de Anúncios da Meta | Sim para ativar a feature | |
Dados.gov.br | Opcional (melhora rate limits) | |
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 # opcionalConfiguração
Variável | Default | Descrição |
| — | Chave do Portal da Transparência |
| — | Chave do DataJud/CNJ |
| — | Chave da API OpenSanctions |
| — | Token da Meta Graph API para anúncios eleitorais |
| — | Token bearer do dados.gov.br (opcional) |
|
| Modo de discovery: |
|
| Timeout HTTP em segundos |
|
| 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 OllamaModelos 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 |
|
| Provider LLM: |
|
| URL base do servidor Ollama |
|
| Modelo Ollama a usar |
| — | Chave Anthropic (necessária quando |
Documentação
Página | Descrição |
Instalação e configuração em 2 minutos | |
Como o projeto funciona por dentro | |
Catálogo de features e tools disponíveis | |
Meta-tools: planner, batch, discovery | |
Guia para contribuir com novas APIs | |
Variáveis de ambiente e opções | |
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 |
Dashboard econômico com Selic, IPCA, câmbio, PIB | Bacen, IBGE, Transparência | |
Onde vai o dinheiro da sua cidade — 9 TCEs cruzados | TCEs, PNCP, TransfereGov, IBGE | |
Ciclo completo de um PL: Câmara → Senado → Diário Oficial → STF | Câmara, Senado, Diário Oficial, DataJud | |
Fidelidade partidária, coalizões, emendas como poder | Câmara, Senado, TSE, Transparência | |
Séries temporais, política fiscal, câmbio, crédito | Bacen (40K+ séries), IBGE | |
Rastrear emendas, licitações dirigidas, fornecedores suspeitos | Transparência, TCEs, TCU, PNCP, TSE | |
Produção de matérias data-driven com dados verificáveis | Bacen, IBGE, Câmara, INPE, TSE | |
Votação + emendas + despesas + financiamento de um parlamentar | Câmara, Senado, TSE, TransfereGov | |
Avaliar impacto: recursos investidos vs. resultados | TCEs, IBGE, CNES, Transparência, INPE | |
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/promptsArquitetura
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
Fork o repositório
Crie uma feature em
src/mcp_brasil/data/{feature}/ouagentes/{feature}/Exporte
FEATURE_METAno__init__.pyemcp: FastMCPnoserver.pyAdicione testes em
tests/data/{feature}/Rode
make cie 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 toolscall_toolA
Call a tool by name with the given arguments.
Use this to execute tools discovered via search_tools.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The name of the tool to call | |
| arguments | No | Arguments to pass to the tool |
TDQS
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.
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.
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.
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.
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.
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}} ]
| Name | Required | Description | Default |
|---|---|---|---|
| consultas | 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 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.
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.
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.
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.
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.
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.
| 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 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.
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.
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.
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.
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.
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").
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
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 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.
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.
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.
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.
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.
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").
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Natural language query to search for tools |
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 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.
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.
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.
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.
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.
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.
6 tool updates
v0.5.0- First observed
call_tool - First observed
executar_lote - First observed
listar_features - First observed
planejar_consulta - First observed
recomendar_tools - First observed
search_tools
TDQS
Scored across 6 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for Brazilian Federal Senate open data (legislative, administrative, e-Cidadania).
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.
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Brazilian public data API for AI agents. BCB, IBGE, CVM, B3, compliance. x402 payments on Base.
Related MCP Servers
- AlicenseAqualityCmaintenanceAn 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.1028MIT
- AlicenseAqualityCmaintenanceAn 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.71,807MIT

@openar/mcpofficial
AlicenseAqualityDmaintenanceMCP server for Portuguese Parliament open data, enabling AI agents to access legislative initiatives, deputies, plenary votes, petitions, and parliamentary committees.1210 npmMIT- AlicenseNot gradedqualityDmaintenanceThis 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.1MIT