mcp-inegi 0.1.0__tar.gz

mcp_inegi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Inaki Sobera (nanisadw3)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_inegi-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: mcp-inegi
+Version: 0.1.0
+Summary: Servidor MCP para consultar indicadores oficiales del INEGI: población, inflación (INPC), empleo, PIB e IGAE, a nivel nacional, estatal y municipal
+Author-email: Inaki Sobera <inakisobera8@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/itzamna-mx/mcp-inegi
+Project-URL: Repository, https://github.com/itzamna-mx/mcp-inegi
+Project-URL: Issues, https://github.com/itzamna-mx/mcp-inegi/issues
+Keywords: mcp,mcp-server,inegi,mexico,datos-abiertos,inflacion,inpc,pib,censo,ai-agents,claude-desktop,itzamna
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# mcp-inegi
+
+Servidor MCP para que cualquier asistente de IA (Claude, ChatGPT, Gemini, Cursor o un modelo local)
+consulte **indicadores oficiales del INEGI** y conteste citando la fuente: población, inflación,
+empleo, PIB e IGAE, a nivel nacional, estatal y, para datos censales, municipal.
+
+Forma parte de [Itzamná](https://inakisobera.me/itzamna/), una familia de servidores MCP de código
+abierto sobre los datos públicos de México. Proyecto independiente, sin afiliación con el INEGI.
+
+## Qué puedes preguntarle
+
+- *¿Cuál fue la inflación anual de septiembre?* → 3.45 % (INPC, indicador 910406, periodo 2026/09)
+- *¿Cuánta gente vive en Naucalpan?* → 834,434 personas (Censo 2020, municipio 15057)
+- *¿Qué estados tienen más población desocupada?* → compara las 32 entidades con la ENOE
+- *¿Cómo va el PIB?* → variación anual, PIB real en millones de pesos de 2018 e IGAE mensual
+
+Cada respuesta trae el ID del indicador, el periodo, la unidad, la fuente oficial y la fecha de
+última actualización, para que cualquiera la pueda verificar.
+
+## Herramientas
+
+| Herramienta | Qué hace |
+|---|---|
+| `indicadores_clave` | Catálogo de indicadores verificados, con su ID y cobertura geográfica |
+| `consultar_indicador` | Último valor o serie de un indicador para el país, un estado o un municipio |
+| `comparar_areas` | El mismo indicador en varios estados o municipios, ordenado de mayor a menor |
+| `buscar_municipio` | Clave de un municipio o alcaldía por nombre, sin importar acentos |
+| `metadatos_indicador` | Nombre oficial, unidad, frecuencia, fuente y periodo cubierto |
+
+`consultar_indicador` acepta las claves del catálogo (`INFLACION_ANUAL`, `POBLACION_TOTAL`,
+`TASA_DESOCUPACION`, `PIB_REAL`, `IGAE`…) o cualquier ID numérico del Banco de Indicadores.
+Las áreas se pueden dar por nombre o por clave: estados (`Jalisco`, `CDMX`, `14`) y los 2,478
+municipios y alcaldías (`Naucalpan`, `Juárez, Chihuahua`, `15057`). Si un nombre existe en varios
+estados, como Benito Juárez, el servidor devuelve los candidatos en lugar de adivinar.
+
+## Instalación
+
+1. Pide tu token gratuito en el
+   [INEGI](https://www.inegi.org.mx/app/desarrolladores/generatoken/Usuarios/token_Verify).
+2. Verifica la conexión:
+
+```bash
+export INEGI_TOKEN="tu_token"
+uvx mcp-inegi --test
+```
+
+3. Agrégalo a tu cliente MCP. En Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "inegi": {
+      "command": "uvx",
+      "args": ["mcp-inegi"],
+      "env": { "INEGI_TOKEN": "tu_token" }
+    }
+  }
+}
+```
+
+En Claude Code:
+
+```bash
+claude mcp add inegi -e INEGI_TOKEN=tu_token -- uvx mcp-inegi
+```
+
+## Servidor remoto
+
+```bash
+mcp-inegi --transport streamable-http --host 127.0.0.1 --port 8000 --allowed-host tu.dominio
+```
+
+Detrás de un proxy inverso, `--allowed-host` declara el nombre público para la protección contra
+DNS rebinding.
+
+## Notas sobre la API del INEGI
+
+Cosas que descubrimos al construirlo (octubre de 2026) y que el servidor ya resuelve por ti:
+
+- El banco económico se llama `BIE-BISE`; con `BIE` a secas la API responde que no hay resultados.
+- Se pide siempre la serie completa: con `reciente=true` la API falla en municipios cuando el
+  periodo nacional más nuevo (p. ej. 2025) no existe a ese nivel.
+- El token va en la URL, así que el servidor silencia los logs de `httpx` para no filtrarlo.
+- El catálogo de municipios viene incluido en el paquete (`scripts/generar_municipios.py` lo
+  regenera desde el Marco Geoestadístico).
+- Las respuestas se guardan en caché una hora (`INEGI_CACHE_TTL`, en segundos).
+
+## Desarrollo
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+Licencia MIT.

mcp_inegi-0.1.0/README.md

@@ -0,0 +1,96 @@
+# mcp-inegi
+
+Servidor MCP para que cualquier asistente de IA (Claude, ChatGPT, Gemini, Cursor o un modelo local)
+consulte **indicadores oficiales del INEGI** y conteste citando la fuente: población, inflación,
+empleo, PIB e IGAE, a nivel nacional, estatal y, para datos censales, municipal.
+
+Forma parte de [Itzamná](https://inakisobera.me/itzamna/), una familia de servidores MCP de código
+abierto sobre los datos públicos de México. Proyecto independiente, sin afiliación con el INEGI.
+
+## Qué puedes preguntarle
+
+- *¿Cuál fue la inflación anual de septiembre?* → 3.45 % (INPC, indicador 910406, periodo 2026/09)
+- *¿Cuánta gente vive en Naucalpan?* → 834,434 personas (Censo 2020, municipio 15057)
+- *¿Qué estados tienen más población desocupada?* → compara las 32 entidades con la ENOE
+- *¿Cómo va el PIB?* → variación anual, PIB real en millones de pesos de 2018 e IGAE mensual
+
+Cada respuesta trae el ID del indicador, el periodo, la unidad, la fuente oficial y la fecha de
+última actualización, para que cualquiera la pueda verificar.
+
+## Herramientas
+
+| Herramienta | Qué hace |
+|---|---|
+| `indicadores_clave` | Catálogo de indicadores verificados, con su ID y cobertura geográfica |
+| `consultar_indicador` | Último valor o serie de un indicador para el país, un estado o un municipio |
+| `comparar_areas` | El mismo indicador en varios estados o municipios, ordenado de mayor a menor |
+| `buscar_municipio` | Clave de un municipio o alcaldía por nombre, sin importar acentos |
+| `metadatos_indicador` | Nombre oficial, unidad, frecuencia, fuente y periodo cubierto |
+
+`consultar_indicador` acepta las claves del catálogo (`INFLACION_ANUAL`, `POBLACION_TOTAL`,
+`TASA_DESOCUPACION`, `PIB_REAL`, `IGAE`…) o cualquier ID numérico del Banco de Indicadores.
+Las áreas se pueden dar por nombre o por clave: estados (`Jalisco`, `CDMX`, `14`) y los 2,478
+municipios y alcaldías (`Naucalpan`, `Juárez, Chihuahua`, `15057`). Si un nombre existe en varios
+estados, como Benito Juárez, el servidor devuelve los candidatos en lugar de adivinar.
+
+## Instalación
+
+1. Pide tu token gratuito en el
+   [INEGI](https://www.inegi.org.mx/app/desarrolladores/generatoken/Usuarios/token_Verify).
+2. Verifica la conexión:
+
+```bash
+export INEGI_TOKEN="tu_token"
+uvx mcp-inegi --test
+```
+
+3. Agrégalo a tu cliente MCP. En Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "inegi": {
+      "command": "uvx",
+      "args": ["mcp-inegi"],
+      "env": { "INEGI_TOKEN": "tu_token" }
+    }
+  }
+}
+```
+
+En Claude Code:
+
+```bash
+claude mcp add inegi -e INEGI_TOKEN=tu_token -- uvx mcp-inegi
+```
+
+## Servidor remoto
+
+```bash
+mcp-inegi --transport streamable-http --host 127.0.0.1 --port 8000 --allowed-host tu.dominio
+```
+
+Detrás de un proxy inverso, `--allowed-host` declara el nombre público para la protección contra
+DNS rebinding.
+
+## Notas sobre la API del INEGI
+
+Cosas que descubrimos al construirlo (octubre de 2026) y que el servidor ya resuelve por ti:
+
+- El banco económico se llama `BIE-BISE`; con `BIE` a secas la API responde que no hay resultados.
+- Se pide siempre la serie completa: con `reciente=true` la API falla en municipios cuando el
+  periodo nacional más nuevo (p. ej. 2025) no existe a ese nivel.
+- El token va en la URL, así que el servidor silencia los logs de `httpx` para no filtrarlo.
+- El catálogo de municipios viene incluido en el paquete (`scripts/generar_municipios.py` lo
+  regenera desde el Marco Geoestadístico).
+- Las respuestas se guardan en caché una hora (`INEGI_CACHE_TTL`, en segundos).
+
+## Desarrollo
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+Licencia MIT.

mcp_inegi-0.1.0/mcp_inegi/__init__.py

@@ -0,0 +1,5 @@
+"""mcp-inegi: servidor MCP para indicadores oficiales del INEGI."""
+
+from .constants import PACKAGE_VERSION
+
+__version__ = PACKAGE_VERSION

mcp_inegi-0.1.0/mcp_inegi/areas.py

@@ -0,0 +1,170 @@
+"""Resolución de áreas geográficas: país, estados y municipios por nombre o por clave."""
+
+from __future__ import annotations
+
+import json
+import unicodedata
+from functools import lru_cache
+from importlib.resources import files
+
+from .constants import AREA_NACIONAL, ESTADOS
+
+# Nombres comunes que no coinciden con el nombre oficial del estado.
+_ALIAS_ESTADOS = {
+    "nacional": "00",
+    "mexico": "00",
+    "republica mexicana": "00",
+    "estados unidos mexicanos": "00",
+    "cdmx": "09",
+    "df": "09",
+    "distrito federal": "09",
+    "edomex": "15",
+    "estado de mexico": "15",
+    "coahuila": "05",
+    "michoacan": "16",
+    "veracruz": "30",
+    "queretaro de arteaga": "22",
+    "nl": "19",
+    "bc": "02",
+    "bcs": "03",
+}
+
+# Prefijos que la gente antepone al nombre del municipio.
+_PREFIJOS = ("municipio de ", "municipio ", "alcaldia de ", "alcaldia ", "delegacion ")
+
+
+class AreaAmbiguaError(ValueError):
+    """El nombre coincide con municipios de varios estados."""
+
+    def __init__(self, texto: str, candidatos: list[dict[str, str]]):
+        self.candidatos = candidatos
+        opciones = "; ".join(f"{c['nombre']}, {c['estado']} ({c['clave']})" for c in candidatos[:10])
+        extra = f" y {len(candidatos) - 10} más" if len(candidatos) > 10 else ""
+        super().__init__(
+            f"'{texto}' coincide con {len(candidatos)} municipios: {opciones}{extra}. "
+            "Indica el estado ('Benito Juárez, CDMX') o usa la clave de 5 dígitos."
+        )
+
+
+def normalizar(texto: str) -> str:
+    """Minúsculas, sin acentos y con espacios simples."""
+    sin_acentos = unicodedata.normalize("NFD", texto)
+    sin_acentos = "".join(c for c in sin_acentos if unicodedata.category(c) != "Mn")
+    return " ".join(sin_acentos.lower().replace(".", " ").split())
+
+
+_POR_NOMBRE = {normalizar(nombre): clave for clave, nombre in ESTADOS.items()}
+_POR_NOMBRE.update(_ALIAS_ESTADOS)
+
+
+@lru_cache(maxsize=1)
+def municipios() -> dict[str, str]:
+    """Catálogo {clave de 5 dígitos: nombre oficial}, generado por scripts/generar_municipios.py."""
+    texto = files("mcp_inegi").joinpath("data/municipios.json").read_text(encoding="utf-8")
+    return json.loads(texto)
+
+
+@lru_cache(maxsize=1)
+def _municipios_normalizados() -> list[tuple[str, str]]:
+    return [(clave, normalizar(nombre)) for clave, nombre in municipios().items()]
+
+
+def _estado(texto: str, *, en_contexto: bool = False) -> str | None:
+    """Clave de 2 dígitos de un estado por nombre o número, o None.
+
+    Con `en_contexto` ("Naucalpan, México") "México" es el estado, no el país.
+    """
+    t = normalizar(texto)
+    if t.isdigit() and len(t) <= 2 and t.zfill(2) in ESTADOS:
+        return t.zfill(2)
+    if en_contexto and t == "mexico":
+        return "15"
+    clave = _POR_NOMBRE.get(t)
+    return None if clave == AREA_NACIONAL and en_contexto else clave
+
+
+def _ficha(clave: str) -> dict[str, str]:
+    return {"clave": clave, "nombre": municipios()[clave], "estado": ESTADOS[clave[:2]]}
+
+
+def buscar_municipios(texto: str, estado: str | None = None) -> list[dict[str, str]]:
+    """Municipios que coinciden con `texto`, del mejor nivel de coincidencia disponible.
+
+    Niveles: nombre exacto > el nombre empieza con el texto ("naucalpan" -> "Naucalpan de
+    Juárez") > todas las palabras del texto aparecen en el nombre. Se devuelve solo el mejor
+    nivel con resultados, para que "Juárez" no arrastre a todos los "Benito Juárez".
+    """
+    q = normalizar(texto)
+    for prefijo in _PREFIJOS:
+        if q.startswith(prefijo):
+            q = q[len(prefijo):]
+            break
+    if not q:
+        return []
+
+    clave_estado = None
+    if estado:
+        clave_estado = _estado(estado, en_contexto=True)
+        if clave_estado is None:
+            raise ValueError(f"No reconozco el estado '{estado}'.")
+
+    universo = [
+        (clave, nombre)
+        for clave, nombre in _municipios_normalizados()
+        if clave_estado is None or clave.startswith(clave_estado)
+    ]
+    palabras = q.split()
+    niveles = (
+        lambda n: n == q,
+        lambda n: n.startswith(q + " "),
+        lambda n: all(p in n.split() for p in palabras),
+    )
+    for coincide in niveles:
+        encontrados = [clave for clave, nombre in universo if coincide(nombre)]
+        if encontrados:
+            return [_ficha(c) for c in encontrados]
+    return []
+
+
+def resolver_area(area: str | None) -> str:
+    """Convierte un nombre o clave de área geográfica a la clave que espera la API.
+
+    Acepta "00"/"nacional", la clave de estado con o sin cero ("9" o "09"), el nombre del
+    estado ("Jalisco", "CDMX", "Edomex"), la clave de municipio de 5 dígitos ("15057") o su
+    nombre ("Naucalpan", "Benito Juárez, CDMX"). Si un nombre es a la vez estado y municipio
+    ("Aguascalientes", "Hidalgo") gana el estado; para el municipio, "Hidalgo, Michoacán".
+    "México" a secas se toma como el país; el estado es "Estado de México" o "15".
+    """
+    if area is None or not str(area).strip():
+        return AREA_NACIONAL
+    texto = str(area).strip()
+
+    if texto.isdigit():
+        if len(texto) <= 2:
+            clave = texto.zfill(2)
+            if clave == AREA_NACIONAL or clave in ESTADOS:
+                return clave
+        elif len(texto) == 5 and texto in municipios():
+            return texto
+        raise ValueError(
+            f"Clave de área '{texto}' no válida. Usa '00' (nacional), 2 dígitos para estado "
+            "(p. ej. '09') o 5 dígitos para municipio (estado + municipio, p. ej. '15057')."
+        )
+
+    if "," in texto:
+        nombre, _, estado = texto.rpartition(",")
+        candidatos = buscar_municipios(nombre, estado)
+    else:
+        clave = _POR_NOMBRE.get(normalizar(texto))
+        if clave is not None:
+            return clave
+        candidatos = buscar_municipios(texto)
+
+    if len(candidatos) == 1:
+        return candidatos[0]["clave"]
+    if candidatos:
+        raise AreaAmbiguaError(texto, candidatos)
+    raise ValueError(
+        f"No reconozco el área '{texto}'. Usa el nombre de un estado o municipio "
+        "('Jalisco', 'Naucalpan', 'Benito Juárez, CDMX') o su clave numérica."
+    )

mcp_inegi-0.1.0/mcp_inegi/cli.py

@@ -0,0 +1,157 @@
+"""Interfaz de línea de comandos para mcp-inegi."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+
+from . import __version__
+from .client import InegiAPIError, InegiClient
+from .constants import INEGI_TOKEN_HELP_URL
+from .server import create_server
+
+
+def build_transport_security(allowed_hosts: list[str] | None):
+    """Arma la configuración anti DNS-rebinding para los transportes HTTP.
+
+    Detrás de un proxy inverso el header Host que llega es el nombre público,
+    que la librería no conoce: sin declararlo responde 421 a cada petición.
+    Devolver None deja que la librería aplique su default para loopback.
+    """
+    if not allowed_hosts:
+        return None
+
+    from mcp.server.transport_security import TransportSecuritySettings
+
+    hosts: list[str] = []
+    origins: list[str] = []
+    for nombre in allowed_hosts:
+        # El proxy puede o no incluir el puerto en el Host.
+        for entrada in (nombre, f"{nombre}:*"):
+            if entrada not in hosts:
+                hosts.append(entrada)
+        for entrada in (f"https://{nombre}", f"http://{nombre}"):
+            if entrada not in origins:
+                origins.append(entrada)
+
+    # Conservar loopback para que las pruebas locales sigan funcionando.
+    for entrada in ("127.0.0.1:*", "localhost:*", "[::1]:*"):
+        if entrada not in hosts:
+            hosts.append(entrada)
+    for entrada in ("http://127.0.0.1:*", "http://localhost:*", "http://[::1]:*"):
+        if entrada not in origins:
+            origins.append(entrada)
+
+    return TransportSecuritySettings(
+        enable_dns_rebinding_protection=True,
+        allowed_hosts=hosts,
+        allowed_origins=origins,
+    )
+
+
+def test_connection(token: str | None = None) -> int:
+    """Prueba la conexión a la API del INEGI consultando la inflación anual más reciente."""
+    print("=" * 60)
+    print(f"mcp-inegi v{__version__} - Verificación de conexión a la API del INEGI")
+    print("=" * 60)
+
+    effective_token = token or os.environ.get("INEGI_TOKEN")
+    if not effective_token:
+        print("\n[AVISO] No se detectó la variable de entorno INEGI_TOKEN.")
+        print(f"Para obtener un token gratuito, visita: {INEGI_TOKEN_HELP_URL}\n")
+        print("Ejemplo de uso:")
+        print('  export INEGI_TOKEN="tu_token_aqui"')
+        print("  mcp-inegi\n")
+        return 1
+
+    client = InegiClient(token=effective_token)
+
+    async def _run():
+        print("Consultando inflación anual (INPC, indicador 910406)...")
+        try:
+            res = await client.consultar("INFLACION_ANUAL")
+            ultimo = res["ultimo"] or {}
+            print(f"-> Éxito: periodo {ultimo.get('periodo')}, inflación anual {ultimo.get('valor')} %")
+            return 0
+        except InegiAPIError as e:
+            print(f"[ERROR] Falló la consulta al INEGI: {e}")
+            return 1
+
+    return asyncio.run(_run())
+
+
+def main() -> None:
+    """Punto de entrada principal para el comando mcp-inegi."""
+    parser = argparse.ArgumentParser(
+        prog="mcp-inegi",
+        description=(
+            "Servidor MCP comunitario para consultar indicadores oficiales del INEGI. "
+            "Parte de Itzamná; proyecto independiente, sin afiliación con el INEGI."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"mcp-inegi {__version__}")
+    parser.add_argument(
+        "--token",
+        type=str,
+        default=None,
+        help="Token de la API de Indicadores del INEGI (o configurar variable INEGI_TOKEN)",
+    )
+    parser.add_argument(
+        "--test",
+        action="store_true",
+        help="Verifica la conectividad con la API del INEGI y muestra la inflación anual",
+    )
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse", "streamable-http"],
+        default="stdio",
+        help=(
+            "Tipo de transporte MCP (por defecto: stdio). "
+            "'streamable-http' sirve el endpoint remoto; 'sse' está deprecado."
+        ),
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host de escucha para transportes HTTP (por defecto: 127.0.0.1)",
+    )
+    parser.add_argument(
+        "--allowed-host",
+        action="append",
+        default=[],
+        metavar="HOST",
+        help=(
+            "Nombre público aceptado en el header Host al correr detrás de un "
+            "proxy inverso. Repetible. Sin esto el servidor rechaza con 421."
+        ),
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Puerto de escucha para transportes HTTP (por defecto: 8000)",
+    )
+
+    args = parser.parse_args()
+
+    if args.test:
+        sys.exit(test_connection(args.token))
+
+    server = create_server(token=args.token)
+
+    if args.transport == "stdio":
+        server.run(transport="stdio")
+    else:
+        # Detrás de nginx esto se queda en loopback y el proxy publica el TLS.
+        server.run(
+            transport=args.transport,
+            host=args.host,
+            port=args.port,
+            transport_security=build_transport_security(args.allowed_host),
+        )
+
+
+if __name__ == "__main__":
+    main()