ArcGIS MCP - Servidor Unificado

Servidor MCP para ArcGIS Online y ArcGIS Enterprise que combina:

• ✅ Administración de usuarios, grupos y compartición
• ✅ Gestión completa de items (publicar, exportar, mover, clonar)
• ✅ Geoprocesamiento dinámico
• ✅ Consulta y edición de Feature Layers, Tables y FeatureCollections
• ✅ Administración de ArcGIS Server (servicios, logs, máquinas) — Enterprise
• ✅ Logs del portal con filtros avanzados — Enterprise
• ✅ 152 tools MCP organizadas por módulo

Nota: Funciona tanto con ArcGIS Online como con ArcGIS Enterprise. Algunas funciones específicas (webhooks, notebooks, servidores federados) solo están disponibles en Enterprise.

Inicio rápido

3 pasos para empezar:

1. Descarga o clona esta carpeta (arcgis-mcp)
2. Ejecuta el instalador — clic derecho sobre install.ps1 → Ejecutar con PowerShell
   Detecta Python automáticamente (ArcGIS Pro, sistema, Miniconda/Anaconda o lo instala vía winget). Instala dependencias y configura los IDEs instalados (VS Code, Claude Desktop, Cursor, Claude Code, Codex, OpenCode, OpenClaw).
3. Configurá la autenticación y reiniciá el IDE:
   • Con ArcGIS Pro: abrí Pro, conectate a tu portal — listo.
   • Sin ArcGIS Pro: editá el .env con tu método preferido (OAuth2, API Key, perfil o usuario/contraseña). Ver sección Autenticación.

Proba con: "¿con qué usuario estoy conectado?"

Sin ArcGIS Pro: python test_oauth.py para verificar la conexión.
Con ArcGIS Pro: python test_pro.py.

---

Autenticación

El servidor intenta conectarse automáticamente en este orden:

1. 🖥️ ArcGIS Pro activo (GIS("Pro"))

   • Usa la sesión ya autenticada en ArcGIS Pro
   • El usuario YA debe haber iniciado sesión en Pro
   • No requiere .env si Pro está abierto y conectado
   • Ideal para: Desarrollo local con Pro instalado

2. 🌐 OAuth2 interactivo (Abre navegador)

   • Variables: ARCGIS_USE_OAUTH=true
   • Abre el navegador para que el usuario se autentique
   • El usuario ingresa sus credenciales en el portal ArcGIS
   • Genera token automáticamente tras autenticación exitosa
   • Ideal para: Producción, usuarios finales, apps distribuidas
   • Ejemplo:

     ARCGIS_USE_OAUTH=true
     ARCGIS_URL=https://www.arcgis.com  # O tu portal
     ARCGIS_CLIENT_ID=mi_app_id         # Opcional
     

3. 🔑 Perfil nombrado - Variable ARCGIS_PROFILE (recomendado para desarrollo)

   • Usa credenciales guardadas en el keyring del sistema
   • Más seguro que usuario/contraseña en .env

4. 🔓 API Key - Variable ARCGIS_API_KEY (Enterprise 11.4+ o AGOL)

   • Tokens de larga duración (hasta 1 año)

5. 🎫 Token - Variable ARCGIS_TOKEN (temporal)

   • Para tokens generados externamente

6. 👤 Usuario/Contraseña - Variables ARCGIS_URL, ARCGIS_USER, ARCGIS_PASS

   • Menos seguro, solo para desarrollo local

📦 Instalación

Opción 1: Setup automático (Recomendado)

python setup.py

Este script ejecuta instalación inteligente + verificación automáticamente.

Opción 2: Instalación manual

# Solo instala paquetes faltantes (no reinstala los existentes)
python install_requirements.py

# Verificar que todo quedó bien
python verify_installation.py

Opción 3: pip tradicional (Instala todos los paquetes requeridos)

pip install -r requirements.txt

⚙️ Configuración

🖥️ Modo 1: ArcGIS Pro (Sin configuración)

Si tienes ArcGIS Pro abierto y conectado, no necesitas .env. El servidor detectará automáticamente tu sesión activa.

# 1. Abre ArcGIS Pro y conéctate a tu portal
# 2. Ejecuta el servidor
python arcgis_mcp.py

🌐 Modo 2: OAuth2 Interactivo (Recomendado para producción)

Crea un archivo .env:

ARCGIS_USE_OAUTH=true
ARCGIS_URL=https://www.arcgis.com  # O tu portal Enterprise

# Opcional: Client ID personalizado (si tienes una app registrada)
# ARCGIS_CLIENT_ID=tu_app_client_id

Al ejecutar el servidor, se abrirá automáticamente el navegador para que el usuario se autentique. El token se genera y almacena automáticamente.

🔑 Modo 3: Perfil nombrado (Desarrollo)

Primero crea un perfil con credenciales:

from arcgis.gis import GIS
gis = GIS("https://mi-portal.com/portal", username="mi_usuario")
# Ingresa tu contraseña cuando lo pida
gis.users.me.username  # Verifica que funciona
# Las credenciales se guardan en el keyring del sistema

Luego en .env:

ARCGIS_PROFILE=mi_perfil

📋 Otras opciones

API Key:

ARCGIS_URL=https://mi-portal.com/portal
ARCGIS_API_KEY=tu_api_key_aqui

Usuario/Contraseña:

ARCGIS_URL=https://mi-portal.com/portal
ARCGIS_USER=mi_usuario
ARCGIS_PASS=mi_contraseña

Guardarrailes de seguridad:

# Habilitar operaciones de escritura (crear, editar, eliminar)
ARCGIS_WRITE_ENABLED=true  # false por defecto

🎯 Uso Recomendado: MCP Puro

El servidor está diseñado para usarse como MCP puro (sin HTTP) directamente desde cualquier cliente compatible:

En todos los casos, reemplaza PYTHON_PATH_EXE con el ejecutable de tu entorno ArcGIS Pro
(ej: C:\...\arcgispro-py3-clone\python.exe) y REPO_PATH con la ruta al archivo arcgis_mcp.py.

---

Claude Desktop

Archivo de configuración:

• Windows: %APPDATA%\Claude\claude_desktop_config.json
• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "arcgis-mcp": {
      "command": "PYTHON_PATH_EXE",
      "args": ["REPO_PATH\\arcgis_mcp.py"],
      "env": {
        "ARCGIS_WRITE_ENABLED": "true"
      }
    }
  }
}

Reiniciar Claude Desktop después de editar.

---

Claude Code (CLI)

Claude Code maneja tres scopes. El más práctico es user (disponible en todos tus proyectos):

claude mcp add --scope user --env ARCGIS_WRITE_ENABLED=true --transport stdio arcgis-mcp -- "PYTHON_PATH_EXE" "REPO_PATH/arcgis_mcp.py"

Claude Code escribe la configuración automáticamente — no hace falta editar JSON a mano.

Scope	Archivo	Disponibilidad
local (default)	~/.claude.json	Solo vos, en el proyecto actual
project	.mcp.json en la raíz	Todo el equipo vía git
user	~/.claude.json	Solo vos, en todos los proyectos

Para ver los servidores configurados: claude mcp list

---

Cursor

Archivo: ~/.cursor/mcp.json (global) o .cursor/mcp.json (solo este proyecto).

{
  "mcpServers": {
    "arcgis-mcp": {
      "command": "PYTHON_PATH_EXE",
      "args": ["REPO_PATH\\arcgis_mcp.py"],
      "env": {
        "ARCGIS_WRITE_ENABLED": "true"
      }
    }
  }
}

Cursor recarga la configuración automáticamente; no hace falta reiniciar.

---

OpenCode

Archivo global: ~/.config/opencode/opencode.json
Archivo de proyecto: opencode.json en la raíz del proyecto.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "arcgis-mcp": {
      "type": "local",
      "command": ["PYTHON_PATH_EXE", "REPO_PATH/arcgis_mcp.py"],
      "environment": {
        "ARCGIS_WRITE_ENABLED": "true"
      }
    }
  }
}

Atención: La clave correcta es "environment" (no "env"). OpenCode ignora "env" silenciosamente.

---

Puede usar el metodo pro. Si no, puede usar este metodo pero debe estar diligenciadas las variables: ARCGIS_URL, ARCGIS_CLIENT_ID en el archivo .env

Codex CLI (OpenAI)

Archivo global: ~/.codex/config.toml
Archivo de proyecto: .codex/config.toml en la raíz del proyecto.

Atención: Codex usa TOML, no JSON.

[mcp_servers.arcgis-mcp]
command = "PYTHON_PATH_EXE"
args = ["REPO_PATH/arcgis_mcp.py"]

[mcp_servers.arcgis-mcp.env]
ARCGIS_WRITE_ENABLED = "true"
ARCGIS_PROFILE = "Pro"

O via CLI (escribe en config.toml automáticamente):

codex mcp add arcgis-mcp --env ARCGIS_WRITE_ENABLED=true -- PYTHON_PATH_EXE REPO_PATH/arcgis_mcp.py

---

Kiro (AWS)

Archivo: .kiro/settings/mcp.json dentro del workspace.

{
  "mcpServers": {
    "arcgis-mcp": {
      "command": "PYTHON_PATH_EXE",
      "args": ["REPO_PATH\\arcgis_mcp.py"],
      "env": {
        "ARCGIS_WRITE_ENABLED": "true"
      },
      "autoApprove": ["whoami", "content_search", "user_list", "group_list"]
    }
  }
}

El campo autoApprove es opcional — lista las tools que Kiro ejecuta sin pedir confirmación al usuario.

---

copilot:

📖 Guía completa: esta misma documentación en este README.

---

🚀 Ejecución

Modo 1: MCP Puro (Recomendado) ✅

Para usar desde Claude Desktop o VS Code:

• No ejecutar manualmente
• El cliente MCP (Claude/VS Code) inicia y gestiona el servidor automáticamente
• Ver configuración en la sección anterior

Para testing local:

cd D:\Dev\IA\MCPs\arcgis-mcp
python arcgis_mcp.py

El servidor queda esperando mensajes JSON-RPC en stdin/stdout.

Modo 2: HTTP Server (Solo para Testing/Dev) 🧪

python arcgis_mcp.py --http

Swagger UI: http://localhost:8080/docs
ReDoc: http://localhost:8080/redoc

⚠️ Modo de desarrollo únicamente. No usar en producción.

Modo 3: SSE (HTTP+SSE para clientes remotos)

python arcgis_mcp.py --sse
python arcgis_mcp.py --sse --port 9090  # puerto personalizado

Expone el MCP sobre HTTP+SSE en http://0.0.0.0:8080/sse. Requiere Entra ID configurado para validar tokens Bearer (variables AZURE_TENANT_ID y AZURE_CLIENT_ID_MCP). Si esas variables no están presentes, arranca sin autenticación (útil para pruebas internas).

Setup Inicial (Primera Vez)

Windows:

cd D:\Dev\IA\MCPs\arcgis-mcp
.\setup.ps1

Linux/Mac:

cd ~/arcgis-mcp
python setup.py

🧪 Pruebas de Autenticación

Antes de ejecutar el servidor completo, puedes probar tu configuración de autenticación:

Probar conexión con ArcGIS Pro

python test_pro.py

Verifica que tu sesión de Pro esté activa y funcional.

Probar OAuth2 interactivo

# ArcGIS Online
python test_oauth.py

# Portal Enterprise personalizado
python test_oauth.py --url https://mi-portal.com/portal

# Con Client ID personalizado
python test_oauth.py --url https://mi-portal.com/portal --client-id mi_app_id

Estos scripts te ayudan a diagnosticar problemas de autenticación antes de ejecutar el servidor MCP completo.

🧪 Uso con agentes IA

Este MCP está diseñado para ser consumido por:

• GitHub Copilot
• Cursor
• Claude Code
• VS Code
• OpenCode
• Cualquier cliente MCP compatible

🤖 Agente especializado: arcgis-apyt-dev

El repositorio incluye un agente experto en ArcGIS API for Python que se instala automáticamente con install.ps1 en cada IDE detectado.

Capacidades

El agente opera como orquestador con 4 niveles de escalada:

1. Usa las 152 tools del MCP directamente cuando cubren la tarea
2. Si el MCP no alcanza → busca el path correcto en el API con arcgis_docs_* y ejecuta Python
3. Si la operación es genérica y reutilizable → escribe un nuevo @mcp.tool() en tools/*.py
4. Solo responde "no es posible" cuando los 3 caminos anteriores fallan

Instalación manual (si no usaste install.ps1)

IDE	Archivo fuente	Destino
VS Code / Copilot	agents/arcgis-apyt-dev.vscode.agent.md	%APPDATA%\Code\User\prompts\
Claude Code	agents/arcgis-apyt-dev.claude.md	~/.claude/agents/
Cursor	agents/arcgis-apyt-dev.cursor.mdc	~/.cursor/rules/
Codex CLI	agents/arcgis-apyt-dev.codex.md	Append a ~/.codex/AGENTS.md

Ejemplos de uso del agente

"Descarga todos los attachments del Feature Layer de inspecciones"
→ No existe tool MCP → agente busca FeatureLayer.attachments.get_list() y ejecuta Python directo

"Necesito un tool MCP para clonar grupos entre portales"
→ Agente verifica la API, escribe el @mcp.tool() en tools/users_groups.py y lo registra

"Lista todos los servicios de imagen del Enterprise"
→ server_services_list(service_type="ImageServer") — MCP tool directa

Ejemplos de prompts

🔍 GIS / Portal

"¿Con qué usuario estoy conectado y qué privilegios tengo?"
→ whoami()

"Muestra las propiedades del portal (versión, idioma, región)"
→ gis_properties()

"¿Qué versión tiene este ArcGIS Enterprise?"
→ gis_version()

📦 Contenido — ContentManager

"Busca todos los Feature Layers con la palabra 'catastro'"
→ content_search(query="catastro", item_type="Feature Layer", max_items=50)

"¿Cuáles son los items que ocupan más de 500 MB?"
→ content_find_large(min_mb=500)

📄 Items — Item

"Mostrame todos los detalles del item con ID abc123"
→ item_get(item_id="abc123")

"Exporta ese item a formato Shapefile"
→ item_export(item_id="abc123", export_format="Shapefile", title="catastro_shp")

"Mové el item abc123 a la carpeta 'Proyectos 2024'"
→ item_move(item_id="abc123", folder="Proyectos 2024")

"Clona el item abc123 en la cuenta del usuario jperez"
→ item_clone(item_id="abc123", owner="jperez")

"¿De qué otros items depende el item abc123?"
→ item_dependent_upon(item_id="abc123")

"Protege el item abc123 para que no se pueda borrar"
→ item_protect(item_id="abc123")

"Descarga el thumbnail del item abc123"
→ item_thumbnail(item_id="abc123", save_path="C:/tmp/thumb.png")

👤 Usuarios — UserManager / User

"Lista todos los usuarios del portal"
→ user_list(query="*", max_users=200)

"Muestra el perfil y roles del usuario jperez"
→ user_get(username="jperez")

"Desactiva la cuenta del usuario jperez"
→ user_disable(username="jperez")

"Cambia el rol de jperez a 'publisher'"
→ user_set_role(username="jperez", role="publisher")

"¿Qué contenido tiene publicado el usuario jperez?"
→ user_content(username="jperez")

👥 Grupos — GroupManager / Group

"Lista todos los grupos del portal"
→ group_list(query="*", max_groups=100)

"¿Quiénes son los miembros del grupo con ID grp456?"
→ group_members(group_id="grp456")

"Agrega a jperez y mgarcia al grupo grp456"
→ group_add_users(group_id="grp456", usernames=["jperez", "mgarcia"])

"¿Qué items están compartidos en el grupo grp456?"
→ group_content(group_id="grp456", max_items=100)

"Crea un grupo llamado 'Cartografía' con etiquetas gis, mapas"
→ group_create(title="Cartografía", description="Grupo de cartografía", tags=["gis", "mapas"])

🔗 Compartición — SharingManager

"¿Quién tiene acceso al item abc123?"
→ share_get_access(item_id="abc123")

"Configura público el item abc123"
→ share_set_access(item_id="abc123", access="public")

"Comparte el item abc123 con los grupos grp456 y grp789"
→ share_group_add(item_id="abc123", group_ids=["grp456", "grp789"])

"¿Cuáles son los items públicos del usuario jperez?"
→ share_audit_by_owner(username="jperez")

"Configura privados todos estos items de golpe: abc123, def456, ghi789"
→ share_bulk_set_access(item_ids=["abc123", "def456", "ghi789"], access="private")

⚙️ Geoprocesamiento

"¿Qué tools expone el GP service en esta URL?"
→ gp_discover(gp_url_or_item="https://mi-server/arcgis/rest/services/Recorte/GPServer")

"Ejecuta la tool 'Clip' con esa capa de entrada"
→ gp_run(gp_url_or_item="https://…/Recorte/GPServer", tool_name="Clip",
         params={"input_features": "https://…/FeatureServer/0", "clip_features": "https://…/FeatureServer/1"})

"Busca GP services relacionados con 'buffer' en el portal"
→ gp_search_services(keywords="buffer", max_results=10)

"Muestra los parámetros y descripción de la tool 'Buffer'"
→ gp_tool_help(gp_url_or_item="https://…/GPServer", tool_name="Buffer")

🗂️ Features — FeatureLayer

"¿Qué campos tiene el Feature Layer en esta URL?"
→ fl_fields(layer_ref="https://mi-server/arcgis/rest/services/Catastro/FeatureServer/0")

"Consulta los predios con área mayor a 5000 m²"
→ fl_query_advanced(layer_ref="https://…/FeatureServer/0",
                    where="AREA > 5000", out_fields=["OBJECTID", "PROPIETARIO", "AREA"],
                    return_geometry=True)

"¿Qué operaciones soporta ese layer (edit, query, etc.)?"
→ fl_capabilities(layer_ref="https://…/FeatureServer/0")

"Calcula el campo 'ESTADO' como 'Activo' para todos los features"
→ fl_calculate(layer_ref="https://…/FeatureServer/0",
               where="1=1", calc_expression=[{"field": "ESTADO", "value": "Activo"}])

🗂️ Features — Feature / Table / FLC / FeatureSet / FeatureCollection

"Dame el feature con OBJECTID=42 de esa capa"
→ feature_get(layer_ref="https://…/FeatureServer/0", object_id=42)

"Consulta la tabla de incidentes y devolve los últimos 50 registros"
→ table_query(layer_ref="https://…/FeatureServer/1",
              where="1=1", max_records=50)

"¿Cuáles son los campos de esa tabla?"
→ table_fields(layer_ref="https://…/FeatureServer/1")

"Describí la estructura completa del FeatureLayerCollection"
→ flc_describe(layer_ref="https://…/FeatureServer")

"Calcula estadísticas (count, avg de AREA) de esta consulta"
→ fset_statistics(layer_ref="https://…/FeatureServer/0",
                  where="MUNICIPIO = 'Bogotá'",
                  stat_fields=[{"statisticType": "avg", "onStatisticField": "AREA", "outStatisticFieldName": "avg_area"}])

"Convertí los resultados de esa consulta a GeoJSON"
→ fset_to_geojson(layer_ref="https://…/FeatureServer/0", where="ESTADO = 'Activo'")

📋 Logs del Portal — Enterprise

"Muestra los últimos WARNING de los logs del portal"
→ portal_logs_query(level="WARNING", page_size=200)

"Dame los errores del portal entre el 1 y el 7 de junio"
→ portal_logs_query(start_time="2025-06-01T00:00:00", end_time="2025-06-07T23:59:59",
                    level="SEVERE", page_size=500)

"¿Cuál es la configuración actual de retención de logs del portal?"
→ portal_logs_settings()

"Cambia el nivel de log del portal a WARNING"
→ portal_logs_settings_update(log_level="WARNING", dry_run=False)

🔧 Admin Enterprise — misc

"¿Qué licencias de ArcGIS Pro están disponibles en el portal?"
→ admin_licenses()

"¿Hay servicios detenidos o con errores en este momento?"
→ admin_services_health()

"Lista todos los servidores federados al portal"
→ admin_servers_list()

🖥️ ArcGIS Server — Enterprise

"Lista todos los servicios del servidor de hosting"
→ server_services_list(server_role="HOSTING_SERVER")

"¿Cuál es el estado y métricas del servicio 'Catastro/MapServer'?"
→ server_service_status(service_name="Catastro/MapServer", server_role="HOSTING_SERVER")

"Reinicia el servicio 'Catastro/MapServer' (primero en dry-run)"
→ server_service_restart(service_name="Catastro/MapServer", dry_run=True)
→ server_service_restart(service_name="Catastro/MapServer", dry_run=False)

"Muestra los errores de los últimos logs del servidor"
→ server_logs_query(log_level="SEVERE", num_messages=200, server_role="HOSTING_SERVER")

"¿Qué máquinas forman parte del clúster del servidor?"
→ server_machines_list(server_role="HOSTING_SERVER")

"Dame el hardware de la máquina ARCGIS-SRV01 (CPU, RAM, disco)"
→ server_machine_hardware(machine_name="ARCGIS-SRV01", server_role="HOSTING_SERVER")

"Lista las carpetas disponibles en el Services Directory del servidor"
→ server_services_folders(server_role="HOSTING_SERVER")

"¿Qué servicios hay en la carpeta 'Utilities' del servidor?"
→ server_services_directory_list(folder="Utilities", server_role="HOSTING_SERVER")

🛠️ Tools disponibles

Total: 105 tools MCP organizadas por módulo API de ArcGIS Python

🔍 GIS / Portal (3)

• whoami() — Identidad, plataforma, privilegios de la sesión activa
• gis_properties() — Propiedades del portal (GIS.properties)
• gis_version() — Versión del portal o ArcGIS Enterprise

📦 Contenido — ContentManager (2)

• content_search(query, item_type, max_items) — Buscar items en el portal
• content_find_large(min_mb) — Identificar items que superan un tamaño en MB

📄 Items — Item (21)

• item_get(item_id) — Detalles completos de un item
• item_update(item_id, ...) — Actualizar metadata (WRITE)
• item_protect(item_id) / item_unprotect(item_id) — Protección contra eliminación (WRITE)
• item_metadata(item_id, format) — Metadata en JSON o XML
• item_download(item_id, save_path) — Descargar datos del item
• item_delete(item_id) — Eliminar item (WRITE)
• item_move(item_id, folder) — Mover a carpeta (WRITE)
• item_clone(item_id, ...) — Clonar item (WRITE)
• item_publish(item_id, ...) — Publicar como servicio (WRITE)
• item_export(item_id, ...) — Exportar a formato (WRITE)
• item_share(item_id, ...) — Compartir con grupos/público (WRITE)
• item_layers(item_id) — Capas de un item de servicio
• item_dependent_upon(item_id) — Items de los que este depende
• item_dependent_to(item_id) — Items que dependen de este
• item_related_items(item_id, rel_type) — Items relacionados
• item_reassign(item_id, target_owner) — Reasignar propietario (WRITE)
• item_get_data(item_id) — Datos/JSON interno del item
• item_thumbnail(item_id, save_path) — Descargar thumbnail
• item_add_comment(item_id, comment) — Agregar comentario (WRITE)
• item_resources(item_id) — Recursos adjuntos al item

👤 Usuarios — UserManager / User (8)

• user_list(query, max_users) — Listar usuarios del portal
• user_create(username, ...) — Crear usuario (WRITE, Enterprise)
• user_get(username) — Detalles de un usuario
• user_update(username, ...) — Actualizar datos del usuario (WRITE)
• user_disable(username) — Desactivar cuenta (WRITE)
• user_enable(username) — Activar cuenta (WRITE)
• user_set_role(username, role) — Cambiar rol (WRITE)
• user_content(username) — Items del usuario

👥 Grupos — GroupManager / Group (8)

• group_list(query, max_groups) — Listar grupos
• group_create(title, description, tags) — Crear grupo (WRITE)
• group_get(group_id) — Detalles de un grupo
• group_update(group_id, ...) — Actualizar grupo (WRITE)
• group_add_users(group_id, usernames) — Agregar miembros (WRITE)
• group_remove_users(group_id, usernames) — Remover miembros (WRITE)
• group_content(group_id, max_items) — Items compartidos en el grupo
• group_members(group_id) — Miembros del grupo

🔗 Compartición — SharingManager (12)

• share_get_access(item_id) / share_set_access(...) / share_status(item_id) — Acceso de un item
• share_bulk_set_access(item_ids, access) — Cambio masivo de acceso (WRITE)
• share_audit_public() / share_audit_by_owner(username) — Auditoría de items públicos
• share_group_add(item_id, group_ids) / share_group_remove(...) / share_group_list(item_id) — Grupos de un item
• share_group_replace(...) / share_group_copy(...) / share_group_audit(group_id) — Operaciones de grupo avanzadas

⚙️ Geoprocesamiento (10)

• gp_discover(gp_url_or_item) — Descubrir tools de un GP Service
• gp_run(...) — Ejecutar tool sincrónicamente
• gp_run_async(...) — Ejecutar tool y esperar resultado
• gp_tool_help(gp_url_or_item, tool_name) — Parámetros y docstring de una tool
• gp_search_services(keywords, max_results) — Buscar GP services en el portal
• gp_service_info(gp_url_or_item) — Info REST del service
• gp_linear_unit(distance, units) — Construir LinearUnit
• gp_data_file(url, item_id) — Construir DataFile
• gp_raster_data(url, item_id, format) — Construir RasterData
• gp_run_with_env(...) — Ejecutar con arcgis.env (SR, extent, etc.)

🗂️ Features — FeatureLayer (6)

• fl_fields(layer_ref) — Campos del layer
• fl_query_advanced(...) — Consulta con filtros SQL y espaciales
• fl_edit(...) — Agregar/actualizar/eliminar features (WRITE)
• fl_delete_by_query(...) — Eliminar features por filtro (WRITE)
• fl_calculate(...) — Calcular campo (WRITE)
• fl_capabilities(layer_ref) — Capacidades del layer

🗂️ Features — Feature / Table / FeatureLayerCollection / FeatureSet / FeatureCollection (15)

• Feature (3): feature_get, feature_get_value, feature_update
• Table (3): table_query, table_edit, table_fields
• FeatureLayerCollection (3): flc_describe, flc_update_definition, flc_truncate
• FeatureSet (3): fset_from_query, fset_statistics, fset_to_geojson
• FeatureCollection (3): fc_describe, fc_query, fc_to_feature_layer

📋 Logs del Portal — Enterprise (4)

Solo disponibles en ArcGIS Enterprise con credenciales de administrador.

• portal_logs_query(start_time, end_time, level, query_filter, ...) — Consultar logs con filtros
• portal_logs_clean() — Limpiar todos los logs (WRITE, IRREVERSIBLE)
• portal_logs_settings() — Configuración actual (logLevel, logDir, retención)
• portal_logs_settings_update(...) — Actualizar configuración de logs (WRITE)

🔧 Admin Enterprise — misc (3)

Solo disponibles en ArcGIS Enterprise.

• admin_licenses() — Licencias de ArcGIS Pro disponibles
• admin_services_health() — Servicios detenidos o con errores
• admin_servers_list() — Servidores federados al portal

🖥️ ArcGIS Server — Enterprise (13)

Solo disponibles en ArcGIS Enterprise. Prefijo: server_.

• server_list() — Listar todos los servidores federados
• server_services_list(folder, server_role) — Servicios de un servidor
• server_service_status(service_name, folder, server_role) — Estado y métricas
• server_service_start(...) / server_service_stop(...) / server_service_restart(...) — Control (WRITE)
• server_logs_query(...) — Logs del servidor con filtros
• server_logs_clean(server_role) — Limpiar logs del servidor (WRITE)
• server_machines_list(server_role) — Máquinas del clúster
• server_machine_hardware(machine_name, server_role) — CPU, RAM, disco, SO
• server_service_manifest(...) — Manifest de recursos del servicio
• server_services_directory_list(folder, server_role) / server_services_folders(server_role) — Services Directory REST

---

📚 Ejemplos Python (modo HTTP)

import requests

BASE = "http://localhost:8080/tools"

# Obtener identidad
resp = requests.post(f"{BASE}/whoami", json={})
print(resp.json())

# Buscar contenido
resp = requests.post(
    f"{BASE}/content_search",
    json={"query": "population", "item_type": "Feature Layer", "max_items": 10}
)
print(resp.json())

# Items grandes (> 200 MB)
resp = requests.post(f"{BASE}/content_find_large", json={"min_mb": 200})
print(resp.json())

# Miembros de un grupo
resp = requests.post(f"{BASE}/group_members", json={"group_id": "abc123"})
print(resp.json())

# Logs del portal (últimos WARNING)
resp = requests.post(
    f"{BASE}/portal_logs_query",
    json={"level": "WARNING", "page_size": 100}
)
print(resp.json())

🐛 Troubleshooting

Error: "No se pudo conectar a ArcGIS"

• Verifica que tengas al menos una credencial configurada
• Si usas Pro, verifica que esté abierto y conectado
• Si usas .env, verifica que las variables estén correctas

Error: "Escritura deshabilitada"

• Activa ARCGIS_WRITE_ENABLED=true en .env
• Las tools de escritura tienen dry_run=True por defecto como protección

Error: "Solo disponible en ArcGIS Enterprise"

• Algunas tools (webhooks, notebooks, servidores) solo funcionan en Enterprise
• Verifica tu plataforma con whoami()

Ejemplo de consumo vía HTTP (FastAPI + MCP)

El servidor HTTP corre en http://localhost:8080 (modo --http).

Python

import requests

# Listar usuarios
resp = requests.post("http://localhost:8080/tools/user_list", json={"max_users": 50})
print(resp.json())

# Items del usuario
resp = requests.post("http://localhost:8080/tools/user_content", json={"username": "jsmith"})
print(resp.json())

# Estado de un servicio
resp = requests.post(
    "http://localhost:8080/tools/server_service_status",
    json={"service_name": "MyMapService", "server_role": "HOSTING_SERVER"}
)
print(resp.json())

curl

curl -X POST http://localhost:8080/tools/whoami -H "Content-Type: application/json" -d '{}'

Documentación interactiva

Abre en tu navegador:

• Swagger UI: http://localhost:8080/docs
• ReDoc: http://localhost:8080/redoc