ABAP Development Tools (ADT)

Um servidor MCP para interagir com sistemas SAP usando ABAP Development Tools (ADT).

Documentação

mcp-abap-adt: Seu Portal para ABAP Development Tools (ADT)

Este projeto fornece um servidor que permite interagir com sistemas SAP ABAP usando o Model Context Protocol (MCP). Pense nele como uma ponte que permite que ferramentas como FLUJO, Claude ou Cline (uma extensão do VS Code) conversem com seu sistema ABAP e recuperem informações como código-fonte, estruturas de tabelas e muito mais. É como ter um controle remoto para seu ambiente de desenvolvimento ABAP!

O servidor é publicado no npm como mcp-abap-adt e listado no MCP Registry como io.github.mario-andreschak/mcp-abap-adt, então a maioria dos clientes MCP pode instalá-lo com um único comando.

Este guia foi feito para iniciantes, então vamos percorrer tudo passo a passo. Vamos cobrir:

Pré-requisitos: O que você precisa antes de começar.
Instalação e Configuração: Deixando tudo pronto e funcionando.
Executando o Servidor: Iniciando o servidor em diferentes modos.
Integração com FLUJO: A maneira mais fácil — instalação com um clique a partir do Spotlight/Marketplace.
Integração com Cline: Conectando este servidor à extensão Cline do VS Code.
Integração com Claude Desktop: Adicionando o servidor ao aplicativo Claude Desktop.
Integração com Claude Code: Adicionando o servidor via .mcp.json ou pela CLI.
Solução de Problemas: Problemas comuns e soluções.
Ferramentas Disponíveis: Uma lista dos comandos que você pode usar.

1. Pré-requisitos

Antes de começar, você precisará de algumas coisas:

Um Sistema SAP ABAP: Este servidor se conecta a um sistema ABAP existente. Você precisará de:
- A URL do sistema (ex.: https://my-sap-system.com:8000)
- Um nome de usuário e senha válidos para esse sistema.
- O número do cliente SAP (ex.: 100).
- Certifique-se de que seu sistema SAP permite conexões via ADT (ABAP Development Tools). Isso geralmente envolve garantir que os serviços necessários estejam ativados na transação SICF. Seu administrador de basis pode ajudar com isso. Especificamente, você precisará que os seguintes serviços estejam ativos:
  - /sap/bc/adt
Node.js e npm: Node.js é um runtime JavaScript que permite executar código JavaScript fora de um navegador web. O npm (Node Package Manager) está incluído com o Node.js e é usado para instalar pacotes (bibliotecas de código).
- Baixar Node.js. Escolha a versão LTS (Long Term Support). Esta é a versão mais estável. Siga as instruções de instalação para seu sistema operacional. Certifique-se de incluir o npm na instalação (geralmente já vem incluído por padrão).
- Verificar a Instalação: Após instalar o Node.js, abra um novo terminal (prompt de comando no Windows, Terminal no macOS/Linux) e digite:
```
node -v
npm -v
```
  Você deve ver os números de versão tanto do Node.js quanto do npm. Se você vir um erro, o Node.js pode não estar instalado corretamente, ou pode não estar no PATH do seu sistema. (Veja Solução de Problemas abaixo).
Git (ou GitHub Desktop) (opcional na maioria dos casos): Usaremos o Git para baixar o código do projeto. Você tem duas opções:
- Git: A ferramenta de linha de comando. Baixar Git. Escolha a versão para seu sistema operacional (Windows, macOS, Linux). Siga as instruções de instalação.
- GitHub Desktop: Uma interface gráfica para o Git. Mais fácil para iniciantes! Baixar GitHub Desktop. Siga as instruções de instalação.

2. Instalação e Configuração

Agora, vamos obter o código do projeto e configurá-lo:

Instalar com FLUJO (recomendado)

Veja Integração com FLUJO

Instalar a partir do npm

O servidor é publicado no npm, então você não precisa clonar ou compilar nada. A maioria dos clientes MCP pode executá-lo diretamente com npx:

npx -y mcp-abap-adt

Normalmente você configurará isso dentro do seu cliente MCP em vez de executá-lo manualmente — aponte o cliente para o comando npx com os argumentos ["-y", "mcp-abap-adt"] e forneça suas credenciais SAP como variáveis de ambiente (SAP_URL, SAP_USERNAME, SAP_PASSWORD, SAP_CLIENT; opcionalmente SAP_LANGUAGE, TLS_REJECT_UNAUTHORIZED). Veja as seções de integração abaixo para e Cline.

Para instalá-lo globalmente:

npm install -g mcp-abap-adt

Instalação Manual (a partir do código-fonte)

Clonar o Repositório:
- Usando Git (linha de comando):
  1. Abra um terminal (prompt de comando ou Terminal).
  2. Navegue até o diretório onde deseja armazenar o projeto. Por exemplo, para colocá-lo na sua Área de Trabalho:
```
cd Desktop
```
  3. Clone o repositório:
```
git clone https://github.com/mario-andreschak/mcp-abap-adt
```
  4. Entre no diretório do projeto:
```
cd mcp-abap-adt  # Or whatever the folder name is
```
- Usando GitHub Desktop:
  1. Abra o GitHub Desktop.
  2. Clique em "File" -> "Clone Repository...".
  3. Na aba "URL", cole a URL do repositório.
  4. Escolha um caminho local (onde deseja salvar o projeto no seu computador).
  5. Clique em "Clone".
Instalar Dependências: Isso baixa todas as bibliotecas necessárias que o projeto precisa. No terminal, dentro do diretório raiz, execute:
```
npm install
```
Isso pode levar alguns minutos.
Compilar o Projeto: Isso compila o código em um formato executável.
```
npm run build
```
Criar um arquivo .env: Este arquivo armazena informações sensíveis como suas credenciais SAP. É muito importante manter este arquivo seguro.
1. No diretório raiz, crie um novo arquivo chamado .env (sem extensão).
2. Abra o arquivo .env em um editor de texto (como Notepad, VS Code, etc.).
3. Adicione as seguintes linhas, substituindo os espaços reservados pelas informações reais do seu sistema SAP: Importante: Se sua senha contiver um caractere "#", certifique-se de colocar sua senha entre aspas!
```
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 compartilhe seu arquivo .env com ninguém, e nunca o envie para um repositório Git!

3. Executando o Servidor

Para ser justo, normalmente você não "executa" este servidor por conta própria. Ele deve ser integrado a um cliente MCP como Claude, FLUJO, Cline, etc. Mas você pode executar o servidor manualmente de duas maneiras principais:

Modo Autônomo (Standalone): Isso executa o servidor diretamente, e ele exibirá mensagens no terminal. O servidor iniciará e aguardará conexões de clientes, o que potencialmente o torna inútil, exceto para ver se ele inicia.
Modo de Desenvolvimento/Depuração: Isso executa o servidor com o MCP Inspector. Você pode abrir a URL que ele exibe no seu navegador e começar a explorar.

3.1 Modo Autônomo

Para executar o servidor em modo autônomo, use o seguinte comando no terminal (a partir do diretório raiz):

npm run start

Você deve ver mensagens no terminal indicando que o servidor está em execução. Ele ficará ouvindo conexões de clientes MCP. O servidor continuará em execução até que você o pare (geralmente com Ctrl+C).

3.2 Modo de Desenvolvimento/Depuração (com Inspector)

Este modo é útil para depuração.

Inicie o servidor em modo de depuração:
```
npm run dev
```
Isso iniciará o servidor e exibirá uma mensagem como: 🔍 MCP Inspector is up and running at http://localhost:5173 🚀. Esta é a URL que você usará para abrir o inspector MCP no seu navegador.

4. Integração com

FLUJO é a maneira mais fácil de usar este servidor — sem clonar, compilar ou editar configuração JSON. mcp-abap-adt é um servidor Spotlight selecionado, então ele instala com um único clique:

No FLUJO, navegue até MCP.
Clique em Add Server.
Na aba Spotlight, clique em mcp-abap-adt (ou mude para a aba Marketplace e encontre-o lá).
O FLUJO baixa o pacote automaticamente e abre a aba Local Server. Insira sua URL SAP, Nome de usuário e Senha (e cliente), depois clique em Save.

Pronto — o FLUJO baixa e executa o pacote npm para você.

Transporte Streamable HTTP (via FLUJO)

mcp-abap-adt roda sobre stdio. Se você precisar acessá-lo via streamable HTTP — por exemplo, a partir de outro aplicativo na sua máquina ou de um cliente que só fala HTTP — deixe o FLUJO re-hospedá-lo: instale o servidor no FLUJO como acima e ative a opção "Expose to external apps" no servidor. O mcp-proxy integrado do FLUJO então o serve via HTTP em http://localhost:4200/mcp-proxy/mcp-abap-adt, e qualquer cliente MCP compatível com HTTP pode se conectar com uma configuração como:

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

O FLUJO mantém suas credenciais SAP com o servidor instalado, então a configuração HTTP em si não carrega nenhuma.

5. Integração com Cline

Cline é uma extensão do VS Code que usa servidores MCP para fornecer suporte a linguagens. Veja como conectar este servidor ABAP ao Cline:

Instale o Cline: Se você ainda não instalou, instale a extensão "Cline" no VS Code.
Abra as Configurações do Cline:
- Abra as configurações do VS Code (File -> Preferences -> Settings, ou Ctrl+,).
- Pesquise por "Cline MCP Settings".
- Clique em "Edit in settings.json". Isso abrirá o arquivo cline_mcp_settings.json. O caminho completo geralmente é algo como: C:\Users\username\AppData\Roaming\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json (substitua username pelo seu nome de usuário do Windows).
Adicione a Configuração do Servidor: Você precisará adicionar uma entrada ao objeto mcpServers no arquivo cline_mcp_settings.json. A maneira recomendada é executar o pacote npm publicado via npx e passar suas credenciais SAP como variáveis de ambiente — sem necessidade de compilação 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 ...
  }
}
```
Se você instalou a partir do código-fonte (veja Instalação Manual), aponte command para node com um caminho absoluto para a saída da compilação, ex.: "args": ["C:/PATH_TO/mcp-abap-adt/dist/index.js"], e configure as credenciais via arquivo .env.
Teste a Conexão:
- O Cline deve se conectar automaticamente ao servidor. Você verá o servidor aparecer no painel "MCP Servers" (na extensão Cline, você encontrará diferentes botões no topo).
- Peça ao Cline para obter o código-fonte de um programa e ele deve mencionar o servidor MCP e tentar usar as ferramentas correspondentes.

6. Integração com Claude Desktop

Claude Desktop pode executar este servidor diretamente via pacote npm publicado.

Abra Claude Desktop → Settings → Developer → Edit Config. Isso abre claude_desktop_config.json. O arquivo está localizado em:
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Adicione uma entrada mcp-abap-adt sob mcpServers, preenchendo suas credenciais 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"
      }
    }
  }
}

Salve o arquivo e reinicie o Claude Desktop. As ferramentas ABAP aparecem no menu de ferramentas (🔨).

Dica para Windows: se npx não for encontrado, defina "command": "npx.cmd", ou use o caminho completo para node com o caminho absoluto para dist/index.js de uma instalação a partir do código-fonte.

7. Integração com Claude Code

Claude Code lê servidores MCP de um arquivo .mcp.json na raiz do seu projeto (compartilhado com sua equipe) ou do escopo do usuário/projeto via CLI.

Opção A — .mcp.json na raiz do seu projeto:

{
  "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"
      }
    }
  }
}

Como este arquivo é enviado ao seu repositório, evite colocar senhas reais nele — use valores de espaço reservado que cada desenvolvedor preenche localmente, ou referencie variáveis de ambiente (o Claude Code expande ${VAR} em .mcp.json), ex.: "SAP_PASSWORD": "${SAP_PASSWORD}".

Opção B — adicione pela 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

Adicione --scope project para gravá-lo no .mcp.json compartilhado, ou --scope user para disponibilizá-lo em todos os seus projetos. Verifique com claude mcp list.

8. Solução de Problemas

node -v or npm -v retorna um erro:
- Certifique-se de que o Node.js está instalado corretamente. Primeiro, tente fechar o Terminal/Powershell/cmd.exe no qual você estava executando o comando. Tente reiniciar o computador. Tente reinstalá-lo.
- Garanta que o diretório de instalação do Node.js esteja na variável de ambiente PATH do seu sistema. No Windows, você pode editar as variáveis de ambiente pelas Propriedades do Sistema (pesquise por "variáveis de ambiente" no Menu Iniciar).
npm install falha:
- Certifique-se de que você tem uma conexão com a internet.
- Tente excluir a pasta node_modules e executar npm install novamente.
- Se você estiver atrás de um proxy, talvez seja necessário configurar o npm para usar o proxy. Pesquise online por "npm proxy settings".
O Cline não conecta ao servidor:
- Verifique novamente as configurações em cline_mcp_settings.json. Ele deve ser o caminho absoluto e correto para o diretório root-server, e use barras invertidas duplas no Windows.
- Certifique-se de que o servidor está em execução (use npm run start para verificar).
- Reinicie o VS Code.
- Alternativamente:
- Navegue até a pasta raiz do mcp-abap-adt no seu Explorer, clique com o botão direito e selecione "Abrir PowerShell aqui". (Ou abra um PowerShell e navegue até a pasta usando o comando cd C:/PATH_TO/mcp-abap-adt/)
- Execute "npm install"
- Execute "npm run build"
- Execute "npx @modelcontextprotocol/inspector node dist/index.js"
- Abra seu navegador na URL que ele exibe. Clique em "connect" no lado esquerdo.
- Clique em "Tools" no topo e depois em "List Tools"
- Clique em GetProgram e digite "SAPMV45A" ou qualquer outro nome de relatório como Program Name na direita
- Teste e veja qual é a saída
Erros de conexão SAP:
- Verifique suas credenciais do SAP no arquivo .env.
- Certifique-se de que o sistema SAP está em execução e acessível a partir da sua rede.
- Garanta que seu usuário SAP tenha as autorizações necessárias para acessar os serviços ADT.
- Verifique se os serviços ADT necessários estão ativados na transação SICF.
- Se você estiver usando certificados autoassinados ou houver um problema com a config http do sistema SAP, certifique-se de definir TLS_REJECT_UNAUTHORIZED conforme descrito acima!

9. Ferramentas Disponíveis

Este servidor fornece as seguintes ferramentas, que podem ser usadas através de FLUJO, Cline, Claude Desktop, Claude Code ou qualquer outro cliente MCP:

Nome da Ferramenta	Descrição	Parâmetros de Entrada	Exemplo de Uso (no Cline)
`GetProgram`	Recuperar o código-fonte do programa ABAP.	`program_name` (string): Nome do programa ABAP.	`@tool GetProgram program_name=ZMY_PROGRAM`
`GetClass`	Recuperar o código-fonte da classe ABAP.	`class_name` (string): Nome da classe ABAP.	`@tool GetClass class_name=ZCL_MY_CLASS`
`GetFunctionGroup`	Recuperar o código-fonte do grupo de funções ABAP.	`function_group` (string): Nome do grupo de funções	`@tool GetFunctionGroup function_group=ZMY_FUNCTION_GROUP`
`GetFunction`	Recuperar o código-fonte do módulo de função ABAP.	`function_name` (string), `function_group` (string)	`@tool GetFunction function_name=ZMY_FUNCTION function_group=ZFG`
`GetStructure`	Recuperar a estrutura ABAP.	`structure_name` (string): Nome da estrutura DDIC.	`@tool GetStructure structure_name=ZMY_STRUCT`
`GetTable`	Recuperar a estrutura da tabela ABAP.	`table_name` (string): Nome da tabela de banco de dados ABAP.	`@tool GetTable table_name=ZMY_TABLE`
`GetTableContents`	Recuperar o conteúdo de uma tabela ABAP.	`table_name` (string), `max_rows` (número, opcional, padrão 100)	`@tool GetTableContents table_name=ZMY_TABLE max_rows=50`
`GetCDSView`	Recuperar o código-fonte da visão CDS (fonte DDL).	`cds_view_name` (string): Nome da visão CDS (nome da fonte DDL).	`@tool GetCDSView cds_view_name=I_CURRENCY`
`GetPackage`	Recuperar os detalhes do pacote ABAP.	`package_name` (string): Nome do pacote ABAP.	`@tool GetPackage package_name=ZMY_PACKAGE`
`GetTypeInfo`	Recuperar informações de tipo ABAP.	`type_name` (string): Nome do tipo ABAP.	`@tool GetTypeInfo type_name=ZMY_TYPE`
`GetInclude`	Recuperar o código-fonte do include ABAP	`include_name` (string): Nome do include ABAP`	`@tool GetInclude include_name=ZMY_INCLUDE`
`SearchObject`	Pesquisar objetos ABAP usando pesquisa rápida.	`query` (string), `maxResults` (número, opcional, padrão 100)	`@tool SearchObject query=ZMY* maxResults=20`
`GetInterface`	Recuperar o código-fonte da interface ABAP.	`interface_name` (string): Nome da interface ABAP.	`@tool GetInterface interface_name=ZIF_MY_INTERFACE`
`GetTransaction`	Recuperar os detalhes da transação ABAP.	`transaction_name` (string): Nome da transação ABAP.	`@tool GetTransaction transaction_name=ZMY_TRANSACTION`
`GetBehaviorDefinition`	Recuperar o código-fonte da Definição de Comportamento RAP (BDEF). Requer ~NW 7.54 / S/4HANA.	`behavior_definition_name` (string): Nome da Definição de Comportamento RAP.	`@tool GetBehaviorDefinition behavior_definition_name=ZMY_ENTITY`
`GetServiceDefinition`	Recuperar o código-fonte da Definição de Serviço RAP (SRVD). Requer ~NW 7.54 / S/4HANA.	`service_definition_name` (string): Nome da Definição de Serviço RAP.	`@tool GetServiceDefinition service_definition_name=ZMY_SERVICE`