mcp-brasil-public-apis

{
  "servers": {
    "mcp-brasil": {
      "command": "uvx",
      "args": ["--from", "mcp-brasil", "python", "-m", "mcp_brasil.server"],
      "env": {
        "TRANSPARENCIA_API_KEY": "$TRANSPARENCIA_API_KEY",
        "DATAJUD_API_KEY": "$DATAJUD_API_KEY"
      }
    }
  }
}

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

fastmcp run mcp_brasil.server:mcp --transport http --port 8000
# Server at http://localhost:8000/mcp

# Optional — 26 other APIs work without any keys
TRANSPARENCIA_API_KEY=your_key_here    # https://portaldatransparencia.gov.br/api-de-dados/cadastrar-email
DATAJUD_API_KEY=your_key_here          # https://datajud-wiki.cnj.jus.br/api-publica/acesso
 
# Tuning
MCP_BRASIL_TOOL_SEARCH=bm25            # bm25 | code_mode | none (default: bm25)
MCP_BRASIL_HTTP_TIMEOUT=30.0           # seconds
MCP_BRASIL_HTTP_MAX_RETRIES=3

git clone https://github.com/jxnxts/mcp-brasil.git
cd mcp-brasil
 
make dev              # Install all dependencies (prod + dev)
make test             # Run all tests
make test-feature F=ibge   # Test a single feature
make lint             # Lint + format check
make ruff             # Auto-fix lint + format
make types            # mypy strict mode
make ci               # lint + types + test (full CI)
make run              # Start server (stdio transport)
make serve            # Start server (HTTP :8000)
make inspect          # List all tools/resources/prompts

src/mcp_brasil/
├── server.py              # Auto-discovers features — never edit manually
├── _shared/               # Shared HTTP client, rate limiting, BM25
├── data/                  # 27 API features
│   ├── ibge/
│   │   ├── __init__.py    # exports FEATURE_META
│   │   ├── server.py      # FastMCP instance (exports `mcp`)
│   │   ├── tools.py       # Tool implementations
│   │   ├── client.py      # Async HTTP via httpx
│   │   ├── schemas.py     # Pydantic v2 models
│   │   └── constants.py   # Base URLs, codes
│   ├── bacen/
│   └── ...
└── agentes/               # Intelligent agent features
    └── redator/

mkdir src/mcp_brasil/data/myfeature
touch src/mcp_brasil/data/myfeature/{__init__.py,server.py,tools.py,client.py,schemas.py,constants.py}

from mcp_brasil._shared.types import FeatureMeta
 
FEATURE_META = FeatureMeta(
    name="myfeature",
    description="Short description of the API",
    tags=["category"],
    requires_key=False,
)

from fastmcp import FastMCP
from .tools import register_tools
 
mcp = FastMCP("myfeature")
register_tools(mcp)

import httpx
from mcp_brasil._shared.http import get_client
 
BASE_URL = "https://api.example.gov.br"
 
async def fetch_data(endpoint: str, params: dict) -> dict:
    async with get_client() as client:
        response = await client.get(f"{BASE_URL}/{endpoint}", params=params)
        response.raise_for_status()
        return response.json()

from pydantic import BaseModel, Field
from typing import Optional
 
class MyResult(BaseModel):
    id: str
    name: str
    value: Optional[float] = Field(None, description="Numeric value")

from fastmcp import FastMCP
from .client import fetch_data
from .schemas import MyResult
 
def register_tools(mcp: FastMCP) -> None:
 
    @mcp.tool(description="Busca dados do endpoint X")
    async def buscar_dados(
        codigo: str,
        ano: int = 2024,
    ) -> list[MyResult]:
        """Retorna dados do endpoint X para o código fornecido."""
        raw = await fetch_data("endpoint-x", {"codigo": codigo, "ano": ano})
        return [MyResult(**item) for item in raw.get("data", [])]

import pytest
from unittest.mock import AsyncMock, patch
from mcp_brasil.data.myfeature.tools import register_tools
from fastmcp import FastMCP
 
@pytest.fixture
def mcp():
    server = FastMCP("test-myfeature")
    register_tools(server)
    return server
 
@pytest.mark.asyncio
async def test_buscar_dados(mcp):
    mock_response = {"data": [{"id": "001", "name": "Test", "value": 42.0}]}
    with patch("mcp_brasil.data.myfeature.client.fetch_data", new_callable=AsyncMock) as mock:
        mock.return_value = mock_response
        # call via mcp tool invocation or directly
        from mcp_brasil.data.myfeature.tools import buscar_dados
        result = await buscar_dados(codigo="001")
        assert len(result) == 1
        assert result[0].name == "Test"

"Crie um plano de consulta para analisar o deputado federal João Silva:
gastos, votações, proposições e financiamento de campanha."

"Execute em paralelo: taxa Selic atual, IPCA dos últimos 12 meses, 
e câmbio USD/BRL de hoje."

"Quais tools devo usar para investigar contratos suspeitos em licitações municipais?"

import asyncio
from mcp_brasil.data.bacen.tools import buscar_serie_temporal
from mcp_brasil.data.ibge.tools import buscar_municipios
 
async def main():
    # Selic rate last 12 months
    selic = await buscar_serie_temporal(codigo="432", ultimos=12)
    
    # All municipalities in São Paulo state
    municipios = await buscar_municipios(uf="SP")
    
    print(f"Selic entries: {len(selic)}")
    print(f"SP municipalities: {len(municipios)}")
 
asyncio.run(main())

from mcp_brasil.data.brasilapi.tools import consultar_cnpj, consultar_cep
 
async def lookup():
    empresa = await consultar_cnpj(cnpj="00000000000191")  # Banco do Brasil
    endereco = await consultar_cep(cep="01310100")         # Av. Paulista

# Economic analysis
"Qual a tendência da taxa Selic nos últimos 12 meses? Compare com IPCA."

# Legislative research  
"Quais projetos de lei sobre IA tramitaram na Câmara em 2024? Quem foram os autores?"

# Transparency / anti-corruption
"Quais os 10 maiores contratos do governo federal em 2024?"

# Cross-state comparison
"Compare gastos per capita com saúde em SP e MG cruzando TCE-SP e IBGE."

# Judiciary
"Busque processos sobre licitação irregular no TCU. Quais as penalidades?"

# Electoral finance
"Quais os maiores doadores da campanha do candidato X?"

# Environment
"Quantos focos de queimada foram registrados no Cerrado em agosto 2024?"

# Document generation (redator feature)
"Redija um ofício solicitando informações sobre o contrato 001/2024 
com dados reais do Portal da Transparência."

# Verify installation
python -m mcp_brasil.server --help
 
# Check uvx finds the package
uvx --from mcp-brasil python -c "import mcp_brasil; print(mcp_brasil.__version__)"

MCP_BRASIL_HTTP_TIMEOUT=60.0    # increase timeout
MCP_BRASIL_HTTP_MAX_RETRIES=5   # increase retries

make test-feature F=bacen
make test-feature F=transparencia