ABAP Development Tools (ADT)

Un servidor MCP para interactuar con sistemas SAP utilizando ABAP Development Tools (ADT).

Documentación

mcp-abap-adt: Tu puerta de entrada a las herramientas de desarrollo ABAP (ADT)

Este proyecto proporciona un servidor que te permite interactuar con sistemas SAP ABAP utilizando el Protocolo de Contexto de Modelo (MCP). Piénsalo como un puente que permite que herramientas como FLUJO, Claude o Cline (una extensión de VS Code) se comuniquen con tu sistema ABAP y recuperen información como código fuente, estructuras de tablas y más. ¡Es como tener un control remoto para tu entorno de desarrollo ABAP!

El servidor está publicado en npm como mcp-abap-adt y está listado en el Registro MCP como io.github.mario-andreschak/mcp-abap-adt, por lo que la mayoría de los clientes MCP pueden instalarlo con un solo comando.

Este checkout utiliza TypeScript MCP SDK 2 y soporta el protocolo moderno 2026-07-28 además del legado 2025-11-25 sobre stdio, utilizando el enrutamiento de primer mensaje del SDK. Se requiere Node.js 22 o 24 LTS. La versión del servidor anunciada proviene de package.json. El descubrimiento de herramientas funciona sin credenciales SAP; las llamadas que acceden a SAP requieren la configuración a continuación. Consulta la guía de migración de protocolo.

Las dieciséis herramientas son de solo lectura. Este ejecutable no expone HTTP nativo; cualquier puente HTTP tiene sus propios requisitos de autenticación, origen e implementación. La creación/actualización de pantallas clásicas solicitada en #17 sigue siendo una mejora abierta; consulta el flujo de trabajo soportado y los requisitos de implementación.

Esta guía está diseñada para principiantes, así que recorreremos todo paso a paso. Cubriremos:

Requisitos previos: Qué necesitas antes de comenzar.
Instalación y configuración: Poner todo en funcionamiento.
Ejecutar el servidor: Iniciar el servidor en diferentes modos.
Integración con FLUJO: La forma más fácil: instalación con un clic desde Spotlight/Marketplace.
Integración con Cline: Conectar este servidor a la extensión Cline de VS Code.
Integración con Claude Desktop: Agregar el servidor a la aplicación Claude Desktop.
Integración con Claude Code: Agregar el servidor mediante .mcp.json o la CLI.
Solución de problemas: Problemas comunes y soluciones.
Herramientas disponibles: Una lista de los comandos que puedes usar.

1. Requisitos previos

Antes de comenzar, necesitarás algunas cosas:

Un sistema SAP ABAP: Este servidor se conecta a un sistema ABAP existente. Necesitarás:
- La URL del sistema (por ejemplo, https://my-sap-system.com:8000)
- Un nombre de usuario y contraseña válidos para ese sistema.
- El número de cliente SAP (por ejemplo, 100).
- Asegúrate de que tu sistema SAP permita conexiones mediante ADT (Herramientas de Desarrollo ABAP). Esto generalmente implica asegurarse de que los servicios necesarios estén activados en la transacción SICF. Tu administrador de basis puede ayudarte con esto. Específicamente, necesitarás que los siguientes servicios estén activos:
  - /sap/bc/adt
Node.js y npm: Node.js es un entorno de ejecución de JavaScript que te permite ejecutar código JavaScript fuera de un navegador web. npm (Administrador de Paquetes de Node) está incluido con Node.js y se utiliza para instalar paquetes (bibliotecas de código).
- Descargar Node.js. Elige la versión LTS (Soporte a Largo Plazo). Esta es la versión más estable. Sigue las instrucciones de instalación para tu sistema operativo. Asegúrate de incluir npm en la instalación (generalmente está incluido por defecto).
- Verificar la instalación: Después de instalar Node.js, abre una nueva terminal (símbolo del sistema en Windows, Terminal en macOS/Linux) y escribe:
```
node -v
npm -v
```
  Deberías ver números de versión tanto para Node.js como para npm. Si ves un error, Node.js podría no estar instalado correctamente, o podría no estar en el PATH de tu sistema. (Consulta Solución de problemas a continuación).
Git (o GitHub Desktop) (opcional en la mayoría de los casos): Usaremos Git para descargar el código del proyecto. Tienes dos opciones:
- Git: La herramienta de línea de comandos. Descargar Git. Elige la versión para tu sistema operativo (Windows, macOS, Linux). Sigue las instrucciones de instalación.
- GitHub Desktop: Una interfaz gráfica de usuario para Git. ¡Más fácil para principiantes! Descargar GitHub Desktop. Sigue las instrucciones de instalación.

2. Instalación y configuración

Ahora, obtengamos el código del proyecto y configurémoslo:

Instalar con FLUJO (recomendado)

Consulta Integración con FLUJO

Instalar desde npm

El servidor está publicado en npm, por lo que no necesitas clonar ni compilar nada. La mayoría de los clientes MCP pueden ejecutarlo directamente con npx:

npx -y mcp-abap-adt

Normalmente configurarás esto dentro de tu cliente MCP en lugar de ejecutarlo manualmente: apunta el cliente al comando npx con argumentos ["-y", "mcp-abap-adt"] y proporciona tus credenciales SAP como variables de entorno (SAP_URL, SAP_USERNAME, SAP_PASSWORD, SAP_CLIENT; opcionalmente SAP_LANGUAGE, SAP_CA_FILE). Consulta las secciones de integración a continuación para FLUJO y Cline.

Para instalarlo globalmente en su lugar:

npm install -g mcp-abap-adt

Instalación manual (desde el código fuente)

Clonar el repositorio:
- Usando Git (línea de comandos):
  1. Abre una terminal (símbolo del sistema o Terminal).
  2. Navega al directorio donde deseas almacenar el proyecto. Por ejemplo, para ponerlo en tu Escritorio:
```
cd Desktop
```
  3. Clona el repositorio:
```
git clone https://github.com/mario-andreschak/mcp-abap-adt
```
  4. Cambia al directorio del proyecto:
```
cd mcp-abap-adt  # Or whatever the folder name is
```
- Usando GitHub Desktop:
  1. Abre GitHub Desktop.
  2. Haz clic en "Archivo" -> "Clonar repositorio...".
  3. En la pestaña "URL", pega la URL del repositorio.
  4. Elige una ruta local (donde deseas guardar el proyecto en tu computadora).
  5. Haz clic en "Clonar".
Instalar dependencias: Esto descarga todas las bibliotecas necesarias que el proyecto requiere. En la terminal, dentro del directorio raíz, ejecuta:
```
npm ci
```
Esto podría tomar unos minutos.
Compilar el proyecto: Esto compila el código a un formato ejecutable.
```
npm run build
```
Crear un archivo .env: Este archivo almacena información sensible como tus credenciales SAP. Es muy importante mantener este archivo seguro.
1. En el directorio raíz, crea un nuevo archivo llamado .env (sin extensión).
2. Abre el archivo .env en un editor de texto (como Bloc de notas, VS Code, etc.).
3. Agrega las siguientes líneas, reemplazando los marcadores de posición con la información real de tu sistema SAP: Importante: Si tu contraseña contiene un carácter "#", ¡asegúrate de encerrar tu contraseña entre comillas!
```
SAP_URL=https://your-sap-system.com:8000  # Your SAP system URL
SAP_USERNAME=your_username              # Your SAP username
SAP_PASSWORD=your_password              # Your SAP password
SAP_CLIENT=100                         # Your SAP client
```
  Importante: ¡Nunca compartas tu archivo .env con nadie, y nunca lo confirmes en un repositorio Git!

Configuración de TLS y red de SAP

La verificación de certificados y nombres de host está habilitada por defecto. Para un sistema SAP firmado por la CA privada de tu organización, establece SAP_CA_FILE=/absolute/path/sap-ca.pem a un paquete de CA PEM legible. Esto aumenta las raíces incluidas en Node. Cuando se ejecuta en Docker, monta el paquete como solo lectura y proporciona su ruta en el contenedor. Esto sigue la configuración de confianza TLS de Node.

SAP_URL debe ser el origen HTTP(S) canónico, como https://sap.example:443, sin ruta, consulta, fragmento o credenciales incrustadas. Usa HTTPS para las credenciales SAP. Las redirecciones se rechazan para que la autenticación y las cookies de sesión no puedan reenviarse a otro servidor. Configura el origen final cuando un proxy inverso redirige las solicitudes.

El TLS_REJECT_UNAUTHORIZED=0 documentado anteriormente ahora es una opción explícita de solución de problemas y emite una advertencia en stderr; 1 es el valor predeterminado. Anteriormente, la verificación de certificados se deshabilitaba incondicionalmente independientemente de esa configuración. Una CA personalizada es la forma normal de confiar en un certificado privado; la configuración global NODE_TLS_REJECT_UNAUTHORIZED no es utilizada por este servidor.

SAP_LANGUAGE acepta un código de idioma de dos letras, por ejemplo EN o de. El cliente SAP y el idioma opcional se envían como parámetros de consulta en cada solicitud ADT/CSRF. Cada solicitud tiene un tiempo de espera de 30 segundos y un límite de respuesta de 16 MiB; las llamadas de herramientas tienen un plazo total de 60 segundos y propagan la cancelación. La paginación de texto devuelto existente se mantiene limitada a 40,000 bytes UTF-8. Reduce la consulta si la respuesta ascendente excede el límite de descarga.

3. Ejecutar el servidor

Para ser justos, normalmente no "ejecutas" este servidor por sí solo. Se supone que debe integrarse en un cliente MCP como Claude, FLUJO, Cline, etc. Pero puedes ejecutar manualmente el servidor de dos maneras principales:

Modo independiente: Esto ejecuta el servidor directamente, y generará mensajes en la terminal. El servidor se iniciará y esperará conexiones de clientes, lo que potencialmente lo hace inútil excepto para ver si se inicia.
Modo de desarrollo/depuración: Esto ejecuta el servidor con el Inspector MCP. Puedes abrir la URL que genera en tu navegador y comenzar a experimentar.

3.1 Modo independiente

Para ejecutar el servidor en modo independiente, usa el siguiente comando en la terminal (desde el directorio raíz):

npm run start

Deberías ver mensajes en la terminal que indican que el servidor está en ejecución. Escuchará conexiones de clientes MCP. El servidor seguirá ejecutándose hasta que lo detengas (generalmente con Ctrl+C).

3.2 Modo de desarrollo/depuración (con Inspector)

Este modo es útil para depurar.

Iniciar el servidor en modo de depuración:
```
npm run dev
```
Esto iniciará el servidor y generará un mensaje como: 🔍 MCP Inspector is up and running at http://localhost:5173 🚀. Esta es la URL que usarás para abrir el inspector MCP en tu navegador.

4. Integración con FLUJO

FLUJO es la forma más fácil de usar este servidor: sin clonar, compilar ni editar configuración JSON. mcp-abap-adt es un servidor Spotlight curado, por lo que se instala con un solo clic:

En FLUJO, navega a MCP.
Haz clic en Agregar servidor.
En la pestaña Spotlight, haz clic en mcp-abap-adt (o cambia a la pestaña Marketplace y encuéntralo allí).
FLUJO obtiene el paquete automáticamente y abre la pestaña Servidor local. Ingresa tu URL de SAP, Nombre de usuario y Contraseña (y cliente), luego haz clic en Guardar.

Eso es todo: FLUJO descarga y ejecuta el paquete npm por ti.

Transporte HTTP transmisible (mediante FLUJO)

mcp-abap-adt se ejecuta sobre stdio. Si necesitas alcanzarlo a través de HTTP transmisible — por ejemplo, desde otra aplicación en tu máquina o un cliente que solo habla HTTP — deja que FLUJO lo re-aloje: instala el servidor en FLUJO como se indicó anteriormente, luego activa "Exponer a aplicaciones externas" en el servidor. El mcp-proxy integrado de FLUJO lo sirve entonces sobre HTTP en http://localhost:4200/mcp-proxy/mcp-abap-adt, y cualquier cliente MCP compatible con HTTP puede conectarse con una configuración como:

{
  "mcpServers": {
    "mcp-abap-adt": {
      "type": "http",
      "url": "http://localhost:4200/mcp-proxy/mcp-abap-adt"
    }
  }
}

FLUJO mantiene tus credenciales SAP con el servidor instalado, por lo que la configuración HTTP en sí no contiene ninguna.

5. Integración con Cline

Cline es una extensión de VS Code que utiliza servidores MCP para proporcionar soporte de lenguaje. Así es como conectas este servidor ABAP a Cline:

Instalar Cline: Si aún no lo has hecho, instala la extensión "Cline" en VS Code.
Abrir la configuración de Cline:
- Abre la configuración de VS Code (Archivo -> Preferencias -> Configuración, o Ctrl+,).
- Busca "Cline MCP Settings".
- Haz clic en "Editar en settings.json". Esto abrirá el archivo cline_mcp_settings.json. La ruta completa generalmente es algo como: C:\Users\username\AppData\Roaming\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json (reemplaza username con tu nombre de usuario de Windows).
Agregar la configuración del servidor: Necesitarás agregar una entrada al objeto mcpServers en el archivo cline_mcp_settings.json. La forma recomendada es ejecutar el paquete npm publicado mediante npx y pasar tus credenciales SAP como variables de entorno — sin necesidad de compilación local:
```
{
  "mcpServers": {
    "mcp-abap-adt": {
      "command": "npx",
      "args": ["-y", "mcp-abap-adt"],
      "env": {
        "SAP_URL": "https://your-sap-system.com:8000",
        "SAP_USERNAME": "your_username",
        "SAP_PASSWORD": "your_password",
        "SAP_CLIENT": "100"
      },
      "disabled": false,
      "autoApprove": []
    }
    // ... other server configurations ...
  }
}
```
Si instalaste desde el código fuente en su lugar (consulta Instalación manual), apunta command a node con una ruta absoluta a la salida de compilación, por ejemplo "args": ["C:/PATH_TO/mcp-abap-adt/dist/index.js"], y configura las credenciales mediante el archivo .env.
Probar la conexión:
- Cline debería conectarse automáticamente al servidor. Verás que el servidor aparece en el panel "Servidores MCP" (en la extensión de Cline, encontrarás diferentes botones en la parte superior).
- Pídele a Cline que obtenga el código fuente de un programa y debería mencionar el servidor MCP e intentar usar las herramientas correspondientes.

6. Integración con Claude Desktop

Claude Desktop puede ejecutar este servidor directamente a través del paquete npm publicado.

Abre Claude Desktop → Configuración → Desarrollador → Editar configuración. Esto abre claude_desktop_config.json. El archivo se encuentra en:
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Agrega una entrada mcp-abap-adt bajo mcpServers, completando tus credenciales de SAP:

{
  "mcpServers": {
    "mcp-abap-adt": {
      "command": "npx",
      "args": ["-y", "mcp-abap-adt"],
      "env": {
        "SAP_URL": "https://your-sap-system.com:8000",
        "SAP_USERNAME": "your_username",
        "SAP_PASSWORD": "your_password",
        "SAP_CLIENT": "100"
      }
    }
  }
}

Guarda el archivo y reinicia Claude Desktop. Las herramientas de ABAP aparecen en el menú de herramientas (🔨).

Consejo para Windows: si no se encuentra npx, establece "command": "npx.cmd", o usa la ruta completa a node con la ruta absoluta a dist/index.js desde una instalación de origen.

7. Integración con Claude Code

Claude Code lee los servidores MCP desde un archivo .mcp.json en la raíz de tu proyecto (compartido con tu equipo) o desde el ámbito de usuario/proyecto a través de la CLI.

Opción A — .mcp.json en la raíz de tu proyecto:

{
  "mcpServers": {
    "mcp-abap-adt": {
      "command": "npx",
      "args": ["-y", "mcp-abap-adt"],
      "env": {
        "SAP_URL": "https://your-sap-system.com:8000",
        "SAP_USERNAME": "your_username",
        "SAP_PASSWORD": "your_password",
        "SAP_CLIENT": "100"
      }
    }
  }
}

Debido a que este archivo se confirma en tu repositorio, evita poner contraseñas reales en él — ya sea usando valores de marcador de posición que cada desarrollador complete localmente, o haciendo referencia a variables de entorno (Claude Code expande ${VAR} en .mcp.json), por ejemplo, "SAP_PASSWORD": "${SAP_PASSWORD}".

Opción B — agrégalo desde la CLI:

claude mcp add mcp-abap-adt \
  --env SAP_URL=https://your-sap-system.com:8000 \
  --env SAP_USERNAME=your_username \
  --env SAP_PASSWORD=your_password \
  --env SAP_CLIENT=100 \
  -- npx -y mcp-abap-adt

Agrega --scope project para escribirlo en el .mcp.json compartido, o --scope user para que esté disponible en todos tus proyectos. Verifica con claude mcp list.

8. Paginación de respuestas grandes

Todas las herramientas que devuelven texto admiten los argumentos opcionales startLine y maxLines: GetProgram, GetClass, GetFunctionGroup, GetFunction, GetStructure, GetTable, GetTableContents, GetPackage, GetTypeInfo, GetInclude, SearchObject, GetTransaction, GetCDSView, GetInterface, GetBehaviorDefinition y GetServiceDefinition. GetTableContents.max_rows y SearchObject.maxResults aún limitan los registros ascendentes; la paginación protege de forma independiente el tamaño de la respuesta textual.

startLine es un entero basado en 1. Su valor predeterminado es 1.
maxLines es un entero de 1 a 100,000. Cuando se omite, la herramienta solicita todas las líneas restantes.
Una respuesta pequeña sin ningún argumento de paginación mantiene el content[0].text sin procesar existente exactamente.
Cualquier solicitud de paginación explícita devuelve un sobre JSON en content[0].text.
Un resultado sin paginar que exceda el presupuesto conservador de 40,000 bytes UTF-8 se reduce automáticamente y se devuelve en el mismo sobre con autoPaged: true y capped: true.
Una solicitud más allá del final del archivo devuelve content: "", returnedLines: 0 y hasMore: false.

El sobre tiene esta forma:

{
  "content": "...returned source lines...",
  "totalLines": 7745,
  "startLine": 1,
  "returnedLines": 1200,
  "hasMore": true,
  "autoPaged": true,
  "capped": true
}

content es el texto seleccionado, totalLines describe el resultado serializado completo y returnedLines cuenta las líneas de origen consumidas. Continúa la paginación normal con startLine + returnedLines mientras hasMore sea verdadero. autoPaged aparece solo cuando el llamador no solicitó paginación. capped significa que el rango solicitado/predeterminado se redujo para cumplir con el presupuesto final de bytes UTF-8 de content[0].text.

Si una sola línea de origen excede el presupuesto, el sobre también contiene truncatedMidLine: true. El prefijo devuelto es seguro para UTF-8 y no divide un par sustituto Unicode, pero el sufijo omitido no se puede recuperar con la paginación basada en líneas. Esa línea cuenta como consumida; hasMore solo indica si existen líneas de origen posteriores.

Los clientes que anteriormente trataban cada resultado como fuente sin procesar deben analizar content[0].text como JSON siempre que soliciten explícitamente paginación o cuando el límite automático devuelva un sobre. Las respuestas pequeñas sin paginar siguen siendo compatibles con versiones anteriores.

La ejecución predeterminada de npm test no requiere credenciales y omite la suite de integración de SAP en vivo. Los mantenedores pueden optar por participar estableciendo RUN_SAP_INTEGRATION=1 antes de ejecutar npm test -- src/index.test.ts.

9. Solución de problemas

node -v o npm -v da un error:
- Asegúrate de que Node.js esté instalado correctamente. Primero intenta cerrar la Terminal/Powershell/cmd.exe en la que estabas ejecutando el comando. Intenta reiniciar tu computadora. Intenta reinstalarlo.
- Asegúrate de que el directorio de instalación de Node.js esté en la variable de entorno PATH de tu sistema. En Windows, puedes editar las variables de entorno a través de Propiedades del sistema (busca "variables de entorno" en el Menú Inicio).
npm install falla:
- Asegúrate de tener una conexión a internet.
- Intenta eliminar la carpeta node_modules y ejecutar npm install nuevamente.
- Si estás detrás de un proxy, es posible que necesites configurar npm para usar el proxy. Busca en línea "npm proxy settings".
Cline no se conecta al servidor:
- Vuelve a verificar la configuración en cline_mcp_settings.json. Debe ser la ruta absoluta correcta al directorio root-server, y usar dobles barras invertidas en Windows.
- Asegúrate de que el servidor esté ejecutándose (usa npm run start para verificar).
- Reinicia VS Code.
- Alternativamente:
- Navega a la carpeta raíz de mcp-abap-adt en tu Explorador, haz clic derecho con Shift y selecciona "Abrir Powershell aquí". (O abre un Powershell y navega a la carpeta usando cd C:/PATH_TO/mcp-abap-adt/).
- Ejecuta "npm install"
- Ejecuta "npm run build"
- Ejecuta "npx @modelcontextprotocol/inspector node dist/index.js"
- Abre tu navegador en la URL que genera. Haz clic en "connect" en el lado izquierdo.
- Haz clic en "Tools" en la parte superior, luego haz clic en "List Tools"
- Haz clic en GetProgram e ingresa "SAPMV45A" o cualquier otro nombre de Reporte como Nombre del Programa a la derecha
- Prueba y observa cuál es la salida
Errores de conexión SAP:
- Verifica tus credenciales de SAP en el archivo .env.
- Asegúrate de que el sistema SAP esté ejecutándose y sea accesible desde tu red.
- Asegúrate de que tu usuario de SAP tenga las autorizaciones necesarias para acceder a los servicios ADT.
- Verifica que los servicios ADT requeridos estén activados en la transacción SICF.
- Para un certificado de CA privado o autofirmado, configura SAP_CA_FILE y verifica que el nombre de host del certificado coincida con SAP_URL. Los códigos de estado HTTP se devuelven sin cuerpos ascendentes; inspecciona los registros del servidor SAP para obtener detalles de autenticación/autorización.

10. Herramientas disponibles

Este servidor proporciona las siguientes herramientas, que se pueden usar a través de FLUJO, Cline, Claude Desktop, Claude Code o cualquier otro cliente MCP. Cada herramienta listada también acepta los parámetros de paginación opcionales compartidos startLine y maxLines descritos anteriormente:

Nombre de la herramienta	Descripción	Parámetros de entrada	Ejemplo de uso (en Cline)
`GetProgram`	Recuperar el código fuente del programa ABAP.	`program_name` (cadena): Nombre del programa ABAP.	`@tool GetProgram program_name=ZMY_PROGRAM`
`GetClass`	Recuperar el código fuente de la clase ABAP.	`class_name` (cadena): Nombre de la clase ABAP.	`@tool GetClass class_name=ZCL_MY_CLASS`
`GetFunctionGroup`	Recuperar el código fuente del grupo de funciones ABAP.	`function_group` (cadena): Nombre del grupo de funciones	`@tool GetFunctionGroup function_group=ZMY_FUNCTION_GROUP`
`GetFunction`	Recuperar el código fuente del módulo de funciones ABAP.	`function_name` (cadena), `function_group` (cadena)	`@tool GetFunction function_name=ZMY_FUNCTION function_group=ZFG`
`GetStructure`	Recuperar la estructura ABAP.	`structure_name` (cadena): Nombre de la estructura DDIC.	`@tool GetStructure structure_name=ZMY_STRUCT`
`GetTable`	Recuperar la estructura de la tabla ABAP.	`table_name` (cadena): Nombre de la tabla de base de datos ABAP.	`@tool GetTable table_name=ZMY_TABLE`
`GetTableContents`	Recuperar el contenido de una tabla ABAP.	`table_name` (cadena), `max_rows` (entero 1-10000, opcional, predeterminado 100)	`@tool GetTableContents table_name=ZMY_TABLE max_rows=50`
`GetCDSView`	Recuperar el código fuente de la vista CDS (fuente DDL).	`cds_view_name` (cadena): Nombre de la vista CDS (nombre de la fuente DDL).	`@tool GetCDSView cds_view_name=I_CURRENCY`
`GetPackage`	Recuperar los detalles del paquete ABAP.	`package_name` (cadena): Nombre del paquete ABAP.	`@tool GetPackage package_name=ZMY_PACKAGE`
`GetTypeInfo`	Recuperar la información del tipo ABAP.	`type_name` (cadena): Nombre del tipo ABAP.	`@tool GetTypeInfo type_name=ZMY_TYPE`
`GetInclude`	Recuperar el código fuente del include ABAP	`include_name` (cadena): nombre del include ABAP`	`@tool GetInclude include_name=ZMY_INCLUDE`
`SearchObject`	Buscar objetos ABAP usando búsqueda rápida.	`query` (cadena), `maxResults` (entero 1-10000, opcional, predeterminado 100)	`@tool SearchObject query=ZMY* maxResults=20`
`GetInterface`	Recuperar el código fuente de la interfaz ABAP.	`interface_name` (cadena): Nombre de la interfaz ABAP.	`@tool GetInterface interface_name=ZIF_MY_INTERFACE`
`GetTransaction`	Recuperar los detalles de la transacción ABAP.	`transaction_name` (cadena): Nombre de la transacción ABAP.	`@tool GetTransaction transaction_name=ZMY_TRANSACTION`
`GetBehaviorDefinition`	Recuperar el código fuente de la definición de comportamiento RAP (BDEF). Requiere ~NW 7.54 / S/4HANA.	`behavior_definition_name` (cadena): Nombre de la definición de comportamiento RAP.	`@tool GetBehaviorDefinition behavior_definition_name=ZMY_ENTITY`
`GetServiceDefinition`	Recuperar el código fuente de la definición de servicio RAP (SRVD). Requiere ~NW 7.54 / S/4HANA.	`service_definition_name` (cadena): Nombre de la definición de servicio RAP.	`@tool GetServiceDefinition service_definition_name=ZMY_SERVICE`

Validación

Ejecuta npm ci && npm run check con Node 22 o 24 y OpenSSL disponible. La suite sin credenciales cubre la paginación existente y los respaldos de ADT, un servidor HTTPS local (confianza, verificaciones de nombre de host, redirecciones, límites, cancelación, cookies/CSRF), clientes SDK modernos/heredados reales y una instalación de npm empaquetada solo para producción. CI también construye e inicia la imagen de Docker.

Las 12 pruebas de integración de SAP en vivo existentes siguen siendo opcionales con RUN_SAP_INTEGRATION=1 y una configuración de SAP válida. Una ejecución simulada/CI exitosa no establece la activación del servicio ADT de un cliente, las autorizaciones, el soporte de endpoints específicos de la versión o el acceso a la red. No se contactó ningún sistema SAP en vivo para esta reparación.