arcmap-mcp

Servidor MCP local para ArcMap 10.5–10.8 (validado en 10.5). 100% abierto,
libre y soberano. Permite a un agente IA (Claude Code, Claude Desktop, Gemini CLI,
Antigravity, OpenCode…) conducir una sesión viva de ArcMap — listar capas,
ejecutar arcpy, encuadrar, simbolizar, exportar series de planos y ver el canvas —
igual que hacen los MCP de QGIS y ArcGIS Pro, pero para ArcMap legacy (que ninguno
de esos cubre).

Arquitectura (sesión viva, dos piezas)

Cliente IA (Claude Code / Desktop / Gemini / Antigravity / OpenCode)
        │  protocolo MCP (stdio)
        ▼
arcmap_mcp_server.py        ← servidor MCP externo (Python 3 + FastMCP): los schemas
        │                      de las 78 herramientas y el contrato con el cliente
        │  socket TCP local  127.0.0.1:27179
        ▼
Add-in .NET (C#)            ← DENTRO de ArcMap: TcpListener + ArcObjects nativo
  ├─ hilo STA de ArcMap     ← capas, layout, exports, render (con cancelación ESC)
  └─ subprocess Python 2.7  ← arcpy out-of-process sobre un snapshot del .mxd
        │                      (execute_arcpy, Data Driven Pages, análisis ambiental)
        ▼
ArcMap ABIERTO y vivo  →  canvas, capas, layout, exportación

El patrón de dos piezas —servidor MCP externo + puente dentro del GIS hablando un
protocolo trivial por socket local— está tomado del
MCP de QGIS (open source), el estándar de
facto de la categoría. Crédito donde corresponde: este proyecto copia ese diseño y lo
lleva a ArcMap.

Las dos piezas son una decisión de diseño, no una provisionalidad:

• El add-in .NET corre dentro de ArcMap y toca el documento vivo vía
  ArcObjects (COM gestionado por el CLR — estable, sin interop manual). Atiende un
  comando por conexión en el puerto 27179; lo que muta el mapa se ejecuta en el hilo
  STA de ArcMap (el único válido para ArcObjects), y lo que es arcpy puro se delega a
  un proceso Python 2.7 aparte que trabaja sobre una copia temporal del documento
  — así un análisis largo no congela la interfaz de ArcMap.
• El servidor externo expone las @mcp.tool() por stdio — el transporte
  que soportan todos los clientes MCP — y reenvía cada comando por TCP local. Servir
  HTTP desde el propio add-in se evaluó y se descartó: no hay SDK MCP para .NET
  Framework 4.5, HttpListener exige reservas URL ACL con permisos de administrador
  (rompería la instalación de un clic) y los clientes stdio necesitarían un proxy
  igualmente.

Estructura del repo

arcmap-mcp/
├── src/      arcmap_mcp_server.py   ← servidor MCP (regístralo en tu cliente IA)
│             auditor_mxd.py · exportar_mxd.py ← procesos hijo Py2.7 de audit_folder y export_mxd_lote
├── addin/    ArcmapMcp.AddIn/       ← código C# del add-in (+ runner.py embebido)
│             ArcmapMcp.Disco/       ← arcmap-mcp-disco.exe: modo disco de edit_mxd_lote y compare_mxd
│             dist/arcmap-mcp.esriaddin  ← add-in listo para instalar (lleva dentro el .exe)
│             build.ps1              ← build sin Visual Studio (dotnet CLI)
├── docs/     INSTALL.md · TOOLS.md · ROADMAP.md · img/ (capturas)
├── tests/    test_client_protocol.py  ← tests automáticos (no necesitan ArcMap)
│             test_runner_py27.py      ← el runner y el auditor bajo Python 2.7, sin arcpy
│             regresion_sesion_viva.py ← barrido manual del catálogo (ArcMap vivo)
│             regresion_ddp.py         ← barrido del atlas (Data Driven Pages, solo lectura)
│             regresion_disco.py       ← edit_mxd_lote contra copias de un .mxd real (modo disco)
│             sonda_puente.py          ← sonda manual de un comando suelto
├── INSTALAR.bat · ACTUALIZAR.bat · install.ps1 · LEEME.txt ← instalación de un clic
├── start-arcmap-mcp.ps1 · empaquetar.ps1 · requirements.txt · CHANGELOG.md · LICENSE · README.md

arcmap-mcp se instala en C:\mcp\arcmap-mcp, extraigas el ZIP donde lo extraigas:
el instalador copia ahí el paquete y registra esa ruta en tus clientes IA, así que la
carpeta donde descomprimiste el ZIP se puede borrar después. Para otra ubicación,
INSTALAR.bat -Destino D:\otra\carpeta (fuera de carpetas sincronizadas tipo
Drive/Dropbox). Si clonas con git, se usa la carpeta del clon.

Herramientas MCP

78 herramientas sobre ArcMap 10.5 (ver docs/TOOLS.md para el catálogo completo con
firmas, ejemplos y los matices de ejecución de cada grupo).

Qué significa «probado», que conviene decirlo con precisión:

• tests/regresion_sesion_viva.py hace 480 comprobaciones contra una sesión de ArcMap
  real y cubre 56 de las 78 tools, con sus casos de error. 🔴 Modifica el
  documento abierto (añade capas, cambia simbología, lanza geoprocesos): se lanza contra
  un mxd de pruebas, nunca contra un proyecto.
• tests/regresion_ddp.py cubre las tres tools del atlas (Data Driven Pages) con 14
  comprobaciones, y es de solo lectura sobre el documento: necesita un mxd con atlas
  habilitado, que en la práctica es siempre uno de producción. Exporta a C:\temp.
• tests/regresion_disco.py prueba edit_mxd_lote contra copias de un .mxd real con 50
  comprobaciones, cada una con su control (lo guardado se lee con arcpy en otro proceso; una
  ruta relativa que se pierde al guardar tiene que salir como no verificada).
• Otros 199 tests corren sin ArcMap (protocolo, argumentos, lectores de .mxd y de Word,
  runner Python 2.7, instalador).
• export_mxd_lote no pasa por el puente y no está en la regresión: se probó sobre planos
  reales, con salida idéntica byte a byte a la exportada a mano.
• El resto de tools se ha ejercitado a mano en trabajo real a lo largo de las
  versiones —series de planos de decenas de páginas, análisis ambiental— pero no están
  en la regresión automática, así que un fallo suyo no lo caza nadie hasta que aparece.

Esto no es una salvedad de manual. El 2026-09-21, al cubrir geodatabases por primera vez
y al lanzar la regresión dos veces en la misma sesión, salió un defecto que llevaba ahí
desde versiones anteriores: las workspace factories dejaban de poder instanciarse y con ellas
add_layer, describe_data y list_feature_classes, hasta cerrar ArcMap. Está corregido en
la 2.12.0 y ya cubierto. Lo que falta por cubrir sigue siendo el sitio donde esperar la
próxima sorpresa: si usas una versión anterior a la 2.12.0, ese fallo está latente.

• Sin ArcMap abierto (leen del disco, no pasan por el puente): describe_mxd
  (versión declarada de un .mxd sin abrirlo, milisegundos) · audit_folder
  (inventario de TODOS los .mxd de una carpeta: versión, capas, fuentes rotas y
  definition queries, abriendo cada documento en un proceso aparte con timeout) ·
  get_ole_tables (las tablas de Word incrustadas en un .mxd, leídas del fichero).

• Esenciales: ping · get_arcmap_info · list_layers · zoom_to_layer ·
  export_pdf · refresh · execute_arcpy (código arcpy arbitrario sobre un
  snapshot del documento — ver matiz en docs/TOOLS.md).

• Series de planos (Data Driven Pages): list_ddp · export_ddp ·
  list_layout_elements · set_text_element · goto_ddp_page · set_definition_query ·
  set_layer_visibility · export_view_png · export_jpg · export_mxd_lote
  (exporta una lista de .mxd del disco, un proceso por documento: la vía para series).

• Capas y datos: select_by_attribute · clear_selection · get_unique_values ·
  count_features · list_fields · get_layer_info · get_layer_features · add_layer
  (también servicios WMS, y capas que no entran en la leyenda) · remove_layer ·
  apply_symbology_from_layer · set_scale.

• Tabla de contenidos y leyenda: add_group (capa de grupo vacía) · move_layer
  (recolocar una capa o grupo sin quitarla) · rename_layer (renombrarla sin
  sustituirla) · set_legend_item (qué enseña la entrada de
  leyenda de una capa, sin cambiarle el aspecto; quitarla o moverla) · set_legend
  (tamaño de letra, columnas y encajar la leyenda en un recuadro sin escalarla).

• Simbología: set_graduated_symbology (rangos, capas de entidades) ·
  set_unique_values_symbology (categorías por valores únicos) ·
  set_raster_symbology (ráster clasificado, estirado o por valores únicos —
  NDVI, FCC, P95, pendientes, y máscaras categóricas con valores transparentes) ·
  set_single_symbology (un solo símbolo con los colores pedidos) · edit_symbol
  (cambia solo lo pedido de la simbología que ya tiene la capa) · list_style_symbols /
  apply_style_symbol (símbolos de tus estilos .style por nombre) ·
  apply_symbology_from_layer (.lyr plantilla).

• Etiquetas: set_labels (expresión, tamaño, color y halo; devuelve cómo quedó
  cada clase y si el mapa usa Maplex o el motor estándar).

• Marcadores espaciales: get_bookmarks · add_bookmark · remove_bookmark ·
  goto_bookmark.

• Geoprocesamiento y mantenimiento: run_geoprocessing · save_mxd · save_mxd_as · open_mxd ·
  list_broken_data_sources · repair_data_source.

• Visualización y catálogo: get_canvas_screenshot (imagen INLINE, el agente
  ve el mapa; cancelable con ESC) · describe_data · list_data_frames / set_active_df ·
  set_extent · get_workspace / set_workspace · list_feature_classes /
  list_tables / list_rasters.

• Análisis ambiental y teledetección (requieren Spatial/3D Analyst; corren fuera
  del proceso de ArcMap → no congelan la GUI): raster_index (índices
  espectrales con nombre: NDVI, GNDVI, NDRE, NDWI, MNDWI, NDMI, NBR, SAVI, EVI — con
  mapeo de bandas Sentinel-2 / Landsat) · hydrology (cuencas, red de drenaje,
  inundación) · contours · topographic_profile · least_cost_path ·
  calculate_geometry.

La filosofía es híbrida: execute_arcpy es la base universal (cualquier análisis
de ArcMap 10.x se puede expresar con él) y los wrappers existen solo para lo
repetitivo y de alto valor.

Guía rápida: tu primer plano en 5 pasos

Con el add-in instalado y el servidor registrado en tu cliente IA, esto es el camino
corto de "no he tocado nada" a "tengo un PNG". Pídeselo al agente en lenguaje normal;
entre paréntesis va la herramienta que acabará usando.

1. Abre ArcMap y pulsa Iniciar en la barra arcmap-mcp. Es el único paso manual, y
   sin él no hay puente.
2. «¿Está vivo el puente?» (ping). Debe devolver la versión del add-in, el
   documento abierto y el número de capas. Si dice PUENTE CAIDO, vuelve al paso 1;
   si dice ocupado, ArcMap está trabajando y te dice en qué y desde cuándo.
3. «Añade esta capa y dime qué hay dentro» (add_layer, list_layers,
   list_fields). A partir de aquí el agente ya conoce tus datos y sus campos.
4. «Simbolízala y encuádrala» (set_graduated_symbology para rangos,
   set_unique_values_symbology para categorías, set_raster_symbology si es ráster;
   luego zoom_to_layer).
5. «Expórtame la vista» (export_view_png, o export_pdf para el layout). Si
   quieres ver el resultado sin salir del chat, get_canvas_screenshot devuelve la
   imagen en línea.

Dos atajos que ahorran disgustos desde el primer día. Si vas a trabajar sobre .mxd que
no conoces, pasa antes describe_mxd o audit_folder: leen los ficheros sin
abrirlos, así que te dicen versión, capas y fuentes rotas de una carpeta entera sin
riesgo de quedarte esperando a un documento con las fuentes caídas. Y cuando encuentres
un encuadre que vas a repetir, guárdalo con add_bookmark y vuelve con goto_bookmark.

Instalación

Antes de empezar

1. Descargar

Sin git (recomendado si no lo usas): en la página del repositorio, botón verde
Code ▸ Download ZIP. Antes de extraerlo, clic derecho en el ZIP ▸ Propiedades ▸
marcar «Desbloquear» ▸ Aceptar: Windows marca lo que viene de internet y ese marcado
puede impedir que ArcMap cargue el add-in. Extrae después la carpeta donde quieras (en
Descargas, por ejemplo): al instalar se copia sola a C:\mcp\arcmap-mcp.

Con git:

git clone https://github.com/pedralcg/arcmap-mcp.git C:\mcp\arcmap-mcp

2. Instalar

Cierra ArcMap y haz doble clic en INSTALAR.bat. Eso es todo: deja arcmap-mcp en
C:\mcp\arcmap-mcp, prepara el entorno del servidor, instala el add-in dentro de ArcMap y
registra el servidor en los clientes IA que encuentre en tu equipo.

Si prefieres la terminal, es el mismo trabajo (desde la carpeta que extrajiste):

powershell -ExecutionPolicy Bypass -File .\install.ps1

El -ExecutionPolicy Bypass hace falta porque Windows no ejecuta scripts .ps1 con
su configuración de fábrica. INSTALAR.bat ya lo lleva puesto.

Por defecto configura todos los clientes IA detectados. Para elegir:
-Clientes claude-desktop (o claude-code, gemini, antigravity, opencode,
todos, ninguno). Es idempotente: repítelo tras cada actualización.

3. Arrancar y verificar

Abre ArcMap. La barra no aparece sola la primera vez: actívala en Customize ▸ Toolbars
▸ arcmap-mcp (ArcMap recuerda después dónde la dejas).

De izquierda a derecha: Iniciar y Detener el puente, Estado, el desplegable de
Autoarranque, Reportar (un problema) y Acerca de. Pon el desplegable en
«Autoarranque: Sí» y el puente se levantará solo en esta sesión y en todas las
siguientes. Después:

.\install.ps1 -SoloVerificar    # comprueba la instalación y hace un ping real al puente

Reinicia por completo tu cliente IA (el registro de servidores MCP se lee al arrancar) y
pídele la herramienta ping. Para desinstalarlo todo: .\install.ps1 -Desinstalar.

Si algo no va, el botón Estado dice si el puente está activo, qué versión del add-in
está cargada (la que ArcMap tiene instalada, que es la que cuenta), si hay una más nueva,
cuántas peticiones y errores lleva la sesión y dónde está el log:

Acerca de abre en el navegador una ficha con la versión, el estado de la sesión,
ejemplos de qué pedirle al asistente y los enlaces para actualizar o informar de un
problema:

4. Actualizar

El add-in avisa solo cuando hay versión nueva (consulta los tags del repo una vez al día).
Actualizar depende de cómo lo descargaste, y en los dos casos hay que cerrar ArcMap:
mientras está abierto mantiene cargado el add-in y no se puede reemplazar en caliente.

Sin git, tu actualizador es INSTALAR.bat: no hay un segundo fichero que aprender.
install.ps1 es idempotente, así que da igual que sea la primera vez o la quinta: borra el
add-in anterior antes de copiar el nuevo, refresca el entorno del servidor y vuelve a
registrar los clientes. ACTUALIZAR.bat solo le añade el git pull por delante, y si lo
ejecutas sin git te lo dice y no toca nada.

Tras actualizar el add-in, la barra arcmap-mcp no aparecerá sola. Es el comportamiento
correcto desde la 2.8.2: actívala una vez en Customize ▸ Toolbars ▸ arcmap-mcp y ArcMap
recordará su posición. Comprueba con el botón Estado que la versión es la que esperabas.

El servidor MCP (Python) no necesita ceremonia: corre desde C:\mcp\arcmap-mcp (o desde tu
clon git), así que en cuanto el instalador reemplaza los ficheros ya está actualizado. Solo el add-in .NET obliga a cerrar
ArcMap. Detalle completo en docs/INSTALL.md.

Versiones de ArcMap

El add-in se compila contra ArcMap 10.5 y ahí está validado en uso real. ArcMap
carga normalmente add-ins compilados para versiones iguales o anteriores a la instalada,
así que en 10.6–10.8 debería funcionar. En 10.8 (build 12790) está confirmado por un
usuario, incluso instalado en una ruta no estándar: el add-in carga, el puente levanta y la
regresión en sesión viva sale limpia (issue #1). En 10.6 y 10.7 aún no hay confirmación:
si lo pruebas, cuéntalo en una issue.

En 10.4 o anterior no funciona, y el instalador ya no finge lo contrario: si detecta
una de esas versiones lo dice y no instala el add-in (sí prepara el servidor y registra
los clientes). El manifiesto declara <Target version="10.5"> y la DLL enlaza los
ensamblados ESRI 10.5, así que ArcMap no lo cargaría — y no explica por qué. Para usarlo
ahí hay que recompilar: cambiar el <Target> de addin\ArcmapMcp.AddIn\Config.xml,
apuntar las referencias del .csproj a tus ensamblados ESRI y pasar addin\build.ps1.

Instalación manual

Si el instalador no encaja en tu equipo, los pasos equivalentes a mano son los de abajo
(detalle completo, incluida la configuración de cada cliente, en docs/INSTALL.md).

1. Instalar el add-in en ArcMap

Con ArcMap cerrado, doble clic en addin\dist\arcmap-mcp.esriaddin ▸ Install.

Si al abrir ArcMap no aparece la barra arcmap-mcp (el instalador de Esri a veces
falla en silencio), instalación manual: extrae/copia el contenido del .esriaddin
(es un ZIP) a
%USERPROFILE%\Documents\ArcGIS\AddIns\Desktop10.5\{51f4ce63-6bcf-49b2-ae3a-ba2c79ea3e1a}\
y reabre ArcMap. La barra trae 6 botones: Iniciar / Detener / Estado / Autoarranque /
Reportar / Acerca de. Reportar abre un issue de GitHub o un email pre-rellenados
con el diagnóstico de la sesión (sin datos de proyecto); el log, que sí puede contener
nombres de capas y rutas, no se adjunta solo. Al abrir ArcMap, el add-in comprueba en
segundo plano si hay una versión nueva en GitHub y lo indica en Estado y Acerca de
(silencioso si no hay internet).

Pulsa Iniciar → MessageBox «Puente iniciado» y el add-in escucha en
127.0.0.1:27179. El add-in escribe su log en C:\MCP_Logs\arcmap-mcp.log.

2. Levantar / vigilar el túnel

.\start-arcmap-mcp.ps1            # prepara venv, espera al puente, hace ping
.\start-arcmap-mcp.ps1 -Server    # además arranca el servidor MCP (standalone)

El lanzador reintenta hasta que el puente aparece, así que puedes correrlo antes de
arrancar ArcMap: te guía y se conecta solo cuando esté vivo.

3. Registrar en tu cliente IA

Ejemplo Claude Code (.mcp.json del proyecto o config global). Sustituye <USUARIO>
por tu nombre de usuario de Windows:

{
  "mcpServers": {
    "arcmap": {
      "command": "C:/Users/<USUARIO>/AppData/Local/arcmap-mcp/venv/Scripts/python.exe",
      "args": ["C:/mcp/arcmap-mcp/src/arcmap_mcp_server.py"]
    }
  }
}

La guía completa de los 5 clientes está en docs/INSTALL.md.

4. Verificar

Con el puente vivo, pide por MCP la herramienta ping → debe devolver la versión del
add-in, el documento abierto y el nº de capas. Luego list_layers → tus capas. Todo OK.

Acceso remoto (opcional)

El add-in escucha solo en 127.0.0.1, y eso no se puede cambiar: no hay variable
ni ajuste para abrir el bind, a propósito. Si ArcMap corre en otro equipo, reenvía el
puerto con un túnel cifrado — SSH (ssh -L 27179:127.0.0.1:27179 <host>) o Tailscale —
y el servidor MCP se conecta como si fuera local (ARCMAP_BRIDGE_HOST solo si el
extremo local del túnel no es 127.0.0.1).

El túnel no es un rodeo: termina en el 127.0.0.1 de la máquina de destino, así
que alcanza este listener sin abrir nada, y de paso cifra y autentica, que es justo lo
que al puente le falta.

⚠️ Seguridad. El puente expone execute_arcpy, es decir ejecución de código
Python arbitrario en la máquina que aloja ArcMap, sin autenticación, sin usuarios y
sin TLS: quien alcance el puerto ejecuta lo que quiera con los permisos de quien tenga
ArcMap abierto. El loopback no es una limitación pendiente de levantar, es la única
barrera que hay, y por eso el bind se dejó fijo. Lo que sí es configurable es el
puerto, que no cambia nada de esto: se sigue escuchando solo en loopback.

Cambiar el puerto: ARCMAP_BRIDGE_PORT

Por defecto 27179. Existe por un motivo concreto: cuando una instancia de ArcMap se
queda zombi —viva, respondiendo, pero sin ventana principal— sigue sujetando el
puerto, y sin alternativa ningún ArcMap nuevo puede levantar el puente. Con la variable
tienes vía de escape sin matar procesos.

Es la misma variable en los dos extremos: el add-in la lee del entorno del usuario
(defínela antes de abrir ArcMap) y el servidor MCP, de su propio entorno o del
bloque env de la config del cliente. Si solo la pones en uno, no se encuentran. Se
admite 1024–65535; un valor inválido se ignora con aviso en el log y se vuelve al
27179.

Límites conocidos y rendimiento

• Qué congela la GUI y qué no. Las herramientas que corren fuera del proceso
  de ArcMap (execute_arcpy, las 3 de Data Driven Pages y el análisis ambiental) no
  congelan la interfaz: puedes seguir trabajando mientras duran. En cambio
  run_geoprocessing (nativo, dentro de ArcMap) y los exports/render sí ocupan el
  hilo de la interfaz mientras se ejecutan — igual que si los lanzaras a mano. Para un
  geoproceso largo sobre datos en disco, run_geoprocessing(fuera_de_arcmap=True) lo
  lanza aparte (unos 10 s fijos de arranque; las capas viajan por la ruta de su fuente). El
  render y los exports se pueden cancelar con ESC.

• Documentos con marcos OLE (objetos incrustados, p. ej. de Word). Es un fallo de ArcMap
  10.5, no del add-in (pasa igual sin él): la clase del marco OLE la sirve ArcMap desde su
  propio proceso, así que con ArcMap abierto un arcpy de fuera que carga ese .mxd se queda
  esperando una llamada a ArcMap que no vuelve nunca (con ArcMap cerrado abre en un segundo).
  El add-in los cuenta en el documento abierto y lo que abriría una copia fuera de ArcMap
  (execute_arcpy con documento, DDP, la verificación de save_mxd) se niega al momento
  diciendo dónde están; describe_mxd los cuenta sin abrir el fichero, y audit_folder no abre
  con ArcMap abierto los que tienen. Suelen estar fuera de la página, donde no se imprimen:
  borrarlos quita el problema. Si llega a pasar (un script que abre otro .mxd), al cerrar
  ArcMap la ventana se va pero el proceso sigue vivo: no hay nada que guardar, termínalo por PID.

• Semántica de snapshot. Las herramientas out-of-process trabajan sobre una
  copia temporal del .mxd con el estado actual de la sesión: leen el documento
  real (capas, definition queries, atlas), pero sus cambios al documento no
  repercuten en la sesión viva (las salidas a disco sí son reales, y los resultados
  de análisis se añaden al mapa al terminar). Para mutar la sesión viva usa las
  herramientas nativas (set_*, add_layer, …). Coste fijo por llamada: unos
  segundos (snapshot + arranque de Python).

• Documentos con rutas relativas. La copia temporal se hace junto al .mxd
  original en vez de en %TEMP% cuando el documento guarda sus fuentes con rutas
  relativas: llevándola a otra carpeta, esas rutas dejarían de resolver y el snapshot
  abriría con todas las capas rotas. Por eso puede aparecer un fichero oculto
  ~arcmap-mcp-snap_*.mxd junto a tu documento mientras dura la llamada; se borra al
  terminar, y si alguno quedara huérfano el nombre dice de dónde salió.

• Atlas grandes: export_ddp sobre un atlas de cientos de páginas puede agotar la
  espera aun con el timeout amplio; exporta por lista de valores o por rango
  (varias llamadas), que además da feedback por lotes. (No hay parámetro paginas:
  la firma es export_ddp(salida, modo, rango, valores, un_pdf_por_pagina, dpi).)

• Timeouts. No hay uno: hay cinco en el servidor, y cada uno cubre el grupo de
  tools que el add-in atiende de la misma manera.

  Variable (servidor)	Default	Qué cubre
  ARCMAP_BRIDGE_TIMEOUT	60 s	Tools rápidas: consultas, capas, simbología, navegación
  ARCMAP_GP_TIMEOUT	1860 s	Lo que ocupa el hilo de ArcMap: run_geoprocessing, calculate_geometry, export_pdf, export_jpg, export_view_png
  ARCMAP_FONDO_TIMEOUT	2760 s	Lo que va a un handler de fondo: las 3 de Data Driven Pages y las 5 ambientales
  ARCMAP_SAVE_TIMEOUT	630 s	save_mxd, save_mxd_as y open_mxd
  ARCMAP_EXEC_TIMEOUT_CLIENTE	930 s	Solo execute_arcpy
  ARCMAP_EXEC_SESION_TIMEOUT_CLIENTE	1560 s	execute_arcpy con serializar_sesion=True: el add-in gasta hasta 600 s copiando la sesión antes de sus 900 s
  ARCMAP_ESPERA_DIBUJO	120 s	Los tres export cuando llegan con el mapa aún dibujando (E_PENDING, típico justo después de cambiar la vista o las etiquetas): el servidor espera fuera de ArcMap y reintenta cada 3 s

  execute_arcpy no va por ARCMAP_GP_TIMEOUT: subir esa variable no alarga nada
  allí, que es el error que más tiempo ha costado.

  Cada espera del servidor queda por encima del tope que el add-in aplica al mismo
  trabajo (ARCMAP_EXEC_TIMEOUT 900 s, ARCMAP_SUBPROCESS_TIMEOUT 1800 s, más sus
  topes internos de 1800 s en el hilo de ArcMap y 2700 s en el handler de fondo). Es
  deliberado: así vence primero el del add-in, que mata el subproceso y devuelve un
  error diciendo en qué fase se quedó, en vez de un corte mudo de socket que deja el
  runner huérfano (y un runner huérfano impide cerrar ArcMap). Aparte, tu cliente IA
  puede tener su propio timeout de herramienta MCP, normalmente más corto que todo esto.

  Dónde se definen, que no es intercambiable. Las del servidor, en el bloque env
  de la config MCP de tu cliente. Las del add-in (ARCMAP_EXEC_TIMEOUT,
  ARCMAP_SUBPROCESS_TIMEOUT, ARCMAP_PYTHON27), como variables de usuario de
  Windows y antes de abrir ArcMap: el add-in corre dentro del proceso de ArcMap, que
  no ve nada del env del cliente MCP — ponerlas ahí no hace absolutamente nada.

• Extensiones. raster_index, hydrology, least_cost_path requieren Spatial
  Analyst; contours, topographic_profile requieren 3D Analyst (actívalas en
  Customize ▸ Extensions). Si falta la licencia, la herramienta devuelve un error claro.

• Un comando por conexión, en serie. El puente atiende una orden a la vez; si
  llega otra mientras trabaja responde busy de inmediato (sin encolar).

• El puente vive en UNA instancia de ArcMap, y solo ve esa. El add-in se carga en
  todas las ventanas; lo que es único es el puerto (27179), así que lo agarra el
  primer ArcMap donde pulses Iniciar y en los demás el puente no levanta (queda
  anotado en el log, sin romper nada). Consecuencia práctica que despista: con diez
  ArcMap abiertos, get_arcmap_info devuelve un documento, y no es un fallo ni una
  limitación de ArcMap, es que las otras nueve son invisibles para el servidor. Si
  esperabas otro documento, el puente está en otra ventana. Trabaja con una única
  instancia siempre que puedas. Desde la 2.10.0, ARCMAP_BRIDGE_PORT (definida
  antes de abrir ese ArcMap) permite levantar un segundo puente en otro puerto — y es
  también la vía de escape cuando un ArcMap que ya no responde deja cogido el 27179.

• El workspace es por sesión. set_workspace fija el workspace del add-in (no
  hay arcpy.env persistente); se restablece al reiniciar ArcMap.

Estado

• Add-in .NET nativo (ArcObjects vía CLR, sin runtime Python embebido)
• 78 herramientas, incluido el análisis ambiental (índices espectrales, hidrología,
  curvas, perfiles 3D y ruta de mínimo coste) y series de planos reales de decenas
  de páginas. Cobertura automática: 480 comprobaciones en sesión viva sobre 56 de
  ellas, 50 en modo disco y 199 tests sin ArcMap (ver «Herramientas MCP»)
• Geoprocesos arcpy fuera de proceso: la GUI de ArcMap no se congela
• Cancelación de render/exports con ESC (ITrackCancel)
• Registrable en 5 clientes (Claude Code/Desktop, Gemini CLI, Antigravity, OpenCode)

Licencia y contribuciones

El proyecto es libre y abierto (MIT): puedes usarlo, modificarlo y desplegarlo sin
coste. Está pensado para organizaciones que siguen atadas a ArcMap 10.x y quieren
automatizar su trabajo cartográfico con agentes IA sin esperar a migrar a ArcGIS Pro.

Las dudas, fallos y propuestas van por Issues del repositorio.

Recursos de la comunidad

• arcmap-mcp-skill, de
  @HeyElowen: una skill para agentes que trabajan con
  arcmap-mcp (MIT, README en chino, inglés y español). Es un proyecto de su autor, no
  parte de arcmap-mcp.

Créditos

• Patrón de arquitectura: qgis_mcp (Juan
  Santos), el MCP de QGIS open source.
• MIT — © 2026 Pedro Alcoba Gómez · pedralcg.dev · GitHub
  @pedralcg