ABAP Tools - VS Code (Agentic AI)

Inhaltsverzeichnis

• Einleitung
• Architektur
• MCP Server
• Konfiguration
• Plugin
• Gemini (LLM)
• MCP Tools
• agent.md
• instructions.md
• Test
• Fazit

In diesem Artikel schauen wir uns an, wie wir dAgentic AI für VS Code aktivieren und konfigurieren können, um damit erste Anwendungen beziehungsweise Klassen generieren zu lassen.

 

Einleitung

Eine der größten Versprechungen der ABAP Development Tools for Visual Studio Code war vor allem die Nutzung von Agentic AI und AI Agents zur Erstellung von Anwendungen innerhalb des Systems. Im letzten Artikel hatten wir beschrieben, wie wir das Plugin installieren und erste Schritte damit im System unternehmen. Deshalb werden wir uns in diesem Artikel einmal genauer anschauen, wie wir den MCP Server konfigurieren und dann am Ende auch unsere ersten Anwendungen durch einen KI-Agenten generieren lassen. Dabei schauen wir uns die verschiedenen Schritte zur Aktivierung des MCP Servers und weitere Einstellungen an.

 

Architektur

Daher lohnt sich vielleicht ein kleiner Blick auf die Architektur der ABAP Development Tools und wie es nun dahinter aussieht. Dabei hat das Team bei SAP die Architektur umgestellt und stellt nun einen Language Server auf Java-Basis zur Verfügung. Auf diesem Language Server laufen die ABAP Development Tools, die dann wiederum die Schnittstelle zum eigentlichen System herstellen. Damit ist es möglich, unterschiedlichste IDEs an das System anzubinden, ohne dass man jedes Mal eine neue Implementierung vornehmen muss, zumindest was den Backend-Code angeht. Wenn du dann VS Code startest, startet gleichzeitig eine Language Server im Hintergrund und du kannst dir diesen in den Prozessen anschauen.

 

MCP Server

Damit unser Agent nun auf die verschiedenen Tools zugreifen kann, wie zum Beispiel Objekte öffnen, Transporte anlegen oder Informationen aus dem System ziehen, benötigt er gewisse Funktionen. Dafür müssen wir einen MCP Server zur Verfügung stellen, der all diese verschiedenen Features anbietet. Zusammen mit dem Language Server wird mittlerweile auch der MCP Server ausgeliefert. Dieser läuft direkt auf dem Language Server und kann darüber angesprochen werden. Allerdings ist der MCP Server im Auslieferungszustand standardmäßig deaktiviert, sodass wir ihn im ersten Schritt über VS Code aktivieren müssen. Dazu öffnen wir die Einstellungen über "File -> Preferences -> Settings" oder die Shortcut-Kombination "STRG + ," (Komma), um die Einstellungen in VS Code zu öffnen.

 

Dort findest du den Bereich Extensions und kannst die ABAP Development Tools öffnen. Dort scrollst du einmal nach unten und findest drei Einstellungen zum MCP Server:

1. Zum einen kannst du den MCP Server aktivieren.
2. Im zweiten Schritt kannst du den Port ändern.
3. Und im dritten Schritt kannst du ein Security-Token verwenden.

 

 

Das Security-Token kannst du verwenden, wenn du zum Beispiel Claude Code oder Codex verwenden möchtest und dabei den MCP Server ebenfalls einbinden willst. Dafür brauchst du das Security-Token, um dich mit dem Server zu verbinden. Damit bist du nicht unbedingt an VS Code gebunden, sondern kannst auch andere IDEs verwenden.

 

Konfiguration

Für die Konfiguration der KI verwenden wir hier das Copilot-Plugin, welches automatisch mit VS Code ausgeliefert wird und bereits in der IDE integriert ist. Als KI verwenden wir hier ein Gemini Pro Abo, welches wir auch privat nutzen. Hier ist ein Vorteil, dass sich der Copilot immer weiter öffnet und wir auch Modelle nutzen können, die nicht bei Microsoft gehostet werden.

 

Plugin

Sollte das Plugin bei dir geschlossen sein, findest du in der Taskleiste im oberen Bereich eine Schaltfläche, um den Seitenbereich einzublenden. Im Seitenbereich sollte der Chat für den Copilot bereits vorhanden sein. Hier kann es jedoch vorkommen, dass du noch nicht angemeldet bist, das System fordert dich in diesem Fall auf, dich zuerst bei Copilot anzumelden. Alternativ kannst du dort auch direkt ein Large Language Model hinterlegen.

 

Dazu musst du im unteren Teil auf den GitHub Copilot klicken. Dort geht ein entsprechendes Pop-up auf und du kannst die AI Features in der IDE aktivieren. Klickst du auf den Button, dann erfolgt eine Anmeldung am Copilot, hier kannst du auswählen, über welchen Provider du dich anmelden möchtest. Wir melden uns ganz normal mit unserem GitHub-Account an. Die Anmeldung erfolgt dann normalerweise im Browser und du wirst anschließend zurück zur IDE weitergeleitet, wo dann am Ende Copilot auch aktiviert ist.

 

Hinweis: Die Anmeldung bei GitHub ist nicht mehr unbedingt nötig, es kann direkt auch ein API Key verwendet werden, um Modelle (Gemini, Claude, etc.) einzubinden. Dies wurde mit der aktuellen Version gepatcht.

 

Gemini (LLM)

Nachdem alles eingerichtet ist, kannst du klicken, um verschiedene LLMs (Large Language Models) zu wählen. Hier wollen wir ein Gemini Pro Modell hinzufügen. Dazu klickst du auf das Zahnrad im hinteren Bereich bei den Models, um den Konfigurations-Dialog zu starten.

 

Im Dialog klickst du auf den blauen Button "Add Models...", um ein eigenes Modell hinzuzufügen. Hier wählen wir Google als Provider aus. Entsprechend wird im oberen Bereich abgefragt, wie die Kategorie heißen soll, nämlich Google, und dort werden wir nach einem API-Key gefragt. Diesen API-Key kannst du über das Google AI Studio für dein LLM generieren. Grundsätzlich kannst du hier dein eigenes Large Language Model verwenden; du brauchst lediglich den API-Key, um dich mit dem Modell zu verbinden.

 

Nachdem wir den API-Key eingegeben haben, sollten alle Modelle von Google geladen werden, sodass wir diese entsprechend bei den Modellen auswählen können. In diesem Fall verwenden wir das Gemini 3.1 Pro Preview-Modell.

 

MCP Tools

Wir haben zwar den MCP Server aktiviert, aber wir müssen nun noch die MCP Tools aktivieren. Hier können wir selbst entscheiden, ob wir alle Tools oder nur einzelne Tools freigeben wollen. Dazu klickst du im Copilot auf die Konfiguration, um alle Einstellungen einzusehen.

 

Im oberen Bereich öffnet sich dazu ein Menü, in dem wir verschiedene Built-in Tools, aber auch unseren ADT-MCP-Server sehen. Dort können wir direkt auf MCP-Serverebene einen Haken setzen, um alle Tools auf einmal zu aktivieren. Alternativ kannst du dich dazu entscheiden, bestimmte Tools dem LLM nicht zur Verfügung zu stellen. Die Entscheidung liegt ganz bei dir.

 

agent.md

Als Nächstes wollen wir unseren eigenen KI-Agenten anlegen, der für uns die Entwicklung übernehmen soll. Einen Agenten benötigen wir, damit Agentic AI überhaupt funktioniert. Dieser Agent kümmert sich dann um das Coding, das Einholen von Informationen, Code-Reviews oder andere Aufgaben. Grundsätzlich kannst du immer mehrere Agenten anlegen, die auf verschiedene Aufgaben spezialisiert sind. Klicke dazu im Copilot-Plugin auf den Agenten-Modus, dort findest du eine Einstellung, um einen eigenen Agenten anzulegen.

 

In der Command Palette wählst du dann "Create New Custom Agent" aus, um einen neuen Agenten anzulegen. Im nächsten Schritt musst du auswählen, wo die eigentliche Konfigurationsdatei des Agenten (agent.md) abgelegt wird. Hier stehen dir verschiedene Spaces zur Verfügung, zum Beispiel Copilot Agents, wo der Agent direkt für den GitHub Copilot bereitgestellt wird, Claude Agents, wo er für Claude zur Verfügung steht, oder User Data, wo die Datei global in VS Code hinterlegt wird, sowie andere spezifische Use Cases. In diesem Fall wählen wir Copilot Agents (~/.copilot/agents), um unserem Copilot den neuen Agenten zur Verfügung zu stellen.

 

Am Ende erhalten wir unsere agent.md, welche wir nun anpassen können, um die Skills und Tools vorzugeben sowie andere Qualifikationen einzutragen, die der Agent bei der Ausführung beachten soll, zum Beispiel, woher er seine Informationen bezieht und welche spezifische Vorgehensweise er nutzt.

 

Wenn du nicht weißt, was du verwenden sollst, bietet SAP ein kleines Template an, welches über die offizielle SAP-Help Dokumentation zur Verfügung gestellt wird. Damit hast du erste Einstellungen für deinen Agenten und kannst diese weiter verfeinern sowie weitere Tools und Instruktionen hinzufügen. Am Ende können wir dann den Agent auswählen und sehen diesen auch in Copilot.

 

instructions.md

Über den Plus-Button kannst du weitere Tools oder MCP-Server hinzufügen, wenn du diese noch benötigst. Grundsätzlich kannst du darüber auch ein Instruction-File anlegen. In diesem Instruction-File kannst du weitere Anweisungen hinterlegen, wie zum Beispiel, dass der Agent Clean ABAP anwenden oder gewisse Namenskonventionen beachten soll, wenn er bestimmte Objekte (wie CDS-Views oder RAP-Business-Objekte) im System anlegt. Die Instruktionen sind besonders hilfreich, wenn du Standards einhalten willst, ohne jedes Mal manuell nacharbeiten zu müssen. In diesem Fall lassen wir die Instruktionen erst einmal leer; grundsätzlich solltest du sie bei dir aber befüllen und dem Agenten zur Verfügung stellen.

 

Test

Für unseren Test legen wir im System ein Paket unter ZBS_DEMO_AI an. Dieses binden wir dann in unsere Tools ein, um in diesem Paket gleich per KI arbeiten zu können.

 

Geben wir unserem KI-Agenten nun eine erste Aufgabe: Dabei soll er eine Klasse generieren, die unseren RSS-Feed zur Laufzeit einliest und das Ergebnis in eine interne Tabelle parst. Am Ende soll das Ergebnis in der Konsole ausgegeben werden, sodass wir direkt sehen können, welche Artikel aktuell vorhanden sind. Dabei geben wir eine Liste von Aufgaben vor, die durchgeführt werden sollen.

1. Generate an executable class in package ZBS_DEMO_AI in System CloudDEV, that read the content of https://software-heroes.com/user_content/content/feed_en.rss
2. Parse the articles into an internal table
3. Output the table to the console

 

Immer wieder fragt uns der Agent dabei, ob er gewisse Dateien anlegen soll, ob wir einen bestimmten Transport Request nutzen wollen oder ob er bestimmte MCP-Tools verwenden darf. Grundsätzlich ist das ein Standardverhalten, vor allem am Anfang, da das System erst einmal prüft, welche Tools der Agent auch wirklich verwenden möchte. Ansonsten kann man relativ gut verfolgen, welche einzelnen Schritte er durchläuft und welche Objekte er generiert.

 

Wir können auch zwischendurch in den Code der angelegten Klasse schauen, um den aktuellen Stand zu prüfen. Dabei haben wir immer wieder die Möglichkeit, die Änderungen über Keep oder Discard zu übernehmen oder zu verwerfen. Am Ende erhalten wir noch einmal eine komplette Übersicht, welche Objekte und Informationen der Agent generiert hat.

 

Hier findest du den Code, den das LLM im System generiert und iterativ weiterentwickelt hat. Dabei ist der gesamte Code aktiviert worden, das heißt, es waren keine Fehler mehr vorhanden, und die verschiedenen Fehler in der Iteration wurden vom LLM korrigiert. Was auffällt, ist, dass die ungarische Notation verwendet wird. Da wir im Vorfeld keine Instruction mitgegeben haben, diese nicht zu nutzen, hat das LLM automatisch angenommen, dass wir die ungarische Notation im Standard verwenden, wenn wir Code erzeugen.

CLASS zcl_bs_demo_ai_rss_reader DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
    TYPES:
      BEGIN OF ty_article,
        title       TYPE string,
        link        TYPE string,
        description TYPE string,
        pub_date    TYPE string,
      END OF ty_article,
      tt_articles TYPE STANDARD TABLE OF ty_article WITH DEFAULT KEY.

    METHODS get_articles
      RETURNING VALUE(rt_articles) TYPE tt_articles.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_bs_demo_ai_rss_reader IMPLEMENTATION.
  METHOD get_articles.
    DATA ls_article TYPE ty_article.

    TRY.
        DATA(lo_destination) = cl_http_destination_provider=>create_by_url( 'https://software-heroes.com/user_content/content/feed_en.rss' ).
        DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination( lo_destination ).

        DATA(lo_request) = lo_client->get_http_request( ).
        DATA(lo_response) = lo_client->execute( i_method = if_web_http_client=>get ).

        DATA(lv_xml_xstring) = lo_response->get_binary( ).

        DATA(lo_ixml) = cl_ixml_core=>create( ).
        DATA(lo_stream_factory) = lo_ixml->create_stream_factory( ).
        DATA(lo_istream) = lo_stream_factory->create_istream_xstring( lv_xml_xstring ).
        DATA(lo_document) = lo_ixml->create_document( ).
        DATA(lo_parser) = lo_ixml->create_parser(
                            stream_factory = lo_stream_factory
                            istream        = lo_istream
                            document       = lo_document ).

        IF lo_parser->parse( ) = 0.
          DATA(lo_items) = lo_document->get_elements_by_tag_name( name = 'item' ).
          DATA(lo_iterator) = lo_items->create_iterator( ).
          DATA(lo_node) = lo_iterator->get_next( ).

          WHILE lo_node IS BOUND.
            CLEAR ls_article.
            DATA(lo_element) = CAST if_ixml_element( lo_node ).

            DATA(lo_children) = lo_element->get_children( ).
            DATA(lo_child_iterator) = lo_children->create_iterator( ).
            DATA(lo_child_node) = lo_child_iterator->get_next( ).

            WHILE lo_child_node IS BOUND.
              DATA(lv_name) = lo_child_node->get_name( ).
              DATA(lv_value) = lo_child_node->get_value( ).

              CASE lv_name.
                WHEN 'title'.
                  ls_article-title = lv_value.
                WHEN 'link'.
                  ls_article-link = lv_value.
                WHEN 'description'.
                  ls_article-description = lv_value.
                WHEN 'pubDate'.
                  ls_article-pub_date = lv_value.
              ENDCASE.
              lo_child_node = lo_child_iterator->get_next( ).
            ENDWHILE.

            APPEND ls_article TO rt_articles.
            lo_node = lo_iterator->get_next( ).
          ENDWHILE.
        ENDIF.

      CATCH cx_root INTO DATA(lx_error).
        " Handle exception or return empty table
    ENDTRY.
  ENDMETHOD.

  METHOD if_oo_adt_classrun~main.
    DATA(lt_articles) = get_articles( ).
    out->write( lt_articles ).
  ENDMETHOD.
ENDCLASS.

 

Hier ist nun der generierte Testcode, den das LLM erzeugt hat. Hierbei erhalten wir eine Testklasse mit einer Testmethode, welche die eigentliche Methode ausführt, die Artikel holt und anschließend prüft, ob diese nicht leer sind. Grundsätzlich ist das ein einfacher Test, aber voll funktionsfähig für unsere Klasse.

*"* use this source file for your ABAP unit test classes
CLASS ltc_rss_reader DEFINITION FOR TESTING RISK LEVEL HARMLESS DURATION SHORT.
  PRIVATE SECTION.
    METHODS:
      test_get_articles FOR TESTING.
ENDCLASS.

CLASS ltc_rss_reader IMPLEMENTATION.
  METHOD test_get_articles.
    DATA(lo_cut) = NEW zcl_bs_demo_ai_rss_reader( ).
    DATA(lt_articles) = lo_cut->get_articles( ).

    " Assert that articles are returned
    cl_abap_unit_assert=>assert_not_initial(
      act = lt_articles
      msg = 'Articles should not be empty' ).
  ENDMETHOD.
ENDCLASS.

 

Der komplette Code ist generiert und wurde von uns nicht mehr angepasst. Wir haben hier lediglich einen Code-Review auf die Funktion gemacht. Grundsätzlich können wir nun noch über das LLM Anpassungen machen lassen, die ungarische Notation entfernen oder den Stil überarbeiten. Über den Debugger prüfen wir zusätzlich, ob das Parsen funktioniert hat. Die Artikel sind soweit in der internen Tabelle vorhanden:

 

Fazit

Bist du nicht unbedingt schon Profi in dem Bereich Agentic AI oder KI, kann es sein, dass dir die Einrichtung etwas schwerer fällt. Wenn du allerdings schon länger unterwegs bist und die Voraussetzungen sowie die Konfiguration kennst, die man machen muss, dann sollte es dir relativ einfach fallen, Agentic AI auch für ABAP zu aktivieren. Viel Spaß beim Ausprobieren.