🤖 RobotMCP – KI-gestützte Testautomatisierungs-Brücke

Einfaches Englisch hinein, echte Robot-Framework-Tests heraus – mit einem KI-Agenten, der tippt.

RobotMCP (rf-mcp) ist ein Model Context Protocol (MCP)-Server, der deinem Coding-Agenten die Schlüssel zu Robot Framework in die Hand gibt. Der Agent entdeckt Keywords, führt Schritte live gegen Browser, Selenium, Appium, Requests, eine Datenbank oder den Desktop aus, sieht, was tatsächlich passiert – und schreibt dir, sobald die Schritte bestehen, eine saubere .robot-Suite. Keine geratenen Locators, keine halluzinierten Keywords, kein „bei mir funktioniert's". Basiert auf Robot Framework: Open Source und ständig in Entwicklung.

Neu bei rf-mcp? Springe zu Erste Schritte. Du willst das ganze Bild? Siehe die MCP-Tool-Referenz, Konfiguration und ausgearbeitete Beispiele.

📺 Video-Tutorial

Einführung

https://github.com/user-attachments/assets/ad89064f-cab3-4ae6-a4c4-5e8c241301a1

✨ Schnellstart

Drei Befehle und ein Satz. Das ist die gesamte Einrichtung.

1️⃣ Als Werkzeug installieren

Voraussetzungen?

• Python +v3,12 installieren

• Als Admin in Powershell installieren > winget install astral-sh.uv # Um uv-Befehle zu ermöglichen

• VSCode installieren und Erweiterungen (GitHub Copilot und Anmeldung durchführen) # Um Agent-Terminals zu ermöglichen

• VSCode-Erweiterungen Material Icon Themes, Save Typing, Dracula, Robocorp installieren # Um Robot Framework zu ermöglichen

# Everything (Browser, Selenium, Appium, Requests, Database)
uv tool install "rf-mcp[all]"

# ...or just what you need — API testing is pure Python, nothing else to do:
uv tool install "rf-mcp[api]"

Dadurch wird ein robotmcp-Befehl auf deinen PATH gesetzt. Extras entscheiden, welche Testbibliotheken mitkommen – siehe die Extras-Tabelle unter Installation.

2️⃣ In deinen Coding-Agenten einbinden

robotmcp init            # detects libraries, prints the MCP config to paste
robotmcp install         # registers rf-mcp into the agents it finds

robotmcp install schreibt die richtige MCP-Konfiguration für Claude Code, Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose und Cursor – jeweils in deren eigenem Format, ohne deine anderen Server anzufassen. Lieber von Hand? Jeder Agent akzeptiert:

{ "mcpServers": { "robotmcp": { "command": "robotmcp" } } }

{
  "servers": {
    "robotmcp": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "-m", "robotmcp.server"],
      "env": { "UV_COMPILE_BYTECODE": "1" }
    }
  }
}

UV_COMPILE_BYTECODE=1 kompiliert den Abhängigkeitsbaum bereits bei der Installation vor. Ohne sie zahlt der erste Serverstart nach einer Installation/Aktualisierung mehrere Sekunden .pyc-Kompilierung, bevor der MCP-Handshake abgeschlossen ist (einige Clients laufen in einen Timeout und zeigen den Server als nicht verfügbar an). Das ist eine einmalige Kosten bei der Installation.

HTTP

Starte den MCP-Server mit HTTP-Transport:

uv run -m robotmcp.server --transport http --host 127.0.0.1 --port 8000

Dann konfiguriere deinen KI-Agenten:

{
  "servers": {
    "robotmcp": {
      "type": "http",
      "url": "http://localhost:8000/mcp"
    }
  }
}

Claude Code

claude mcp add rf-mcp -- uvx rf-mcp

3️⃣ Testen starten – einfach fragen

Use #robotmcp to create a TestSuite and execute it step wise.
Create a test for https://www.saucedemo.com/ that:
- Logs in to https://www.saucedemo.com/ with valid credentials
- Adds two items to cart
- Completes checkout process
- Verifies success message

Use Selenium Library.
Execute the test suite stepwise and build the final version afterwards.

Das war's. rf-mcp führt den Agenten durch Entdeckung, Live-Ausführung und Suite-Generierung – du beschreibst einfach den Test.

Related MCP server: robotframework-mcp

📚 Dokumentation

🛠️ Installation

Der Schnellstart deckt den empfohlenen Weg ab (uv tool install). Dieser Abschnitt enthält die Extras-Tabelle, alternative Installationsmethoden und die vollständigen Details zur Agenten-Registrierung.

Extras

Extras entscheiden, welche Robot-Framework-Bibliotheken mitkommen:

Browser Library benötigt außerdem Playwright-Browser – führe robotmcp init --browsers (oder rfbrowser init) einmal in rf-mcps eigener Umgebung aus. Node.js wird nur für Browser benötigt.

Andere Installationsmethoden

pip install "rf-mcp[all]"                 # pip instead of uv
uv add "rf-mcp[all]" && uv sync           # into an existing uv project

# From source (development)
git clone https://github.com/manykarim/rf-mcp.git && cd rf-mcp
uv sync --all-extras --dev

Docker

Vorgefertigte Images (headless für CI, plus ein VNC-Image für visuelles Debugging):

docker pull ghcr.io/manykarim/rf-mcp:latest          # headless
docker run -p 8000:8000 -p 8001:8001 ghcr.io/manykarim/rf-mcp:latest    # HTTP + frontend
docker run -it --rm ghcr.io/manykarim/rf-mcp:latest uv run robotmcp     # STDIO

docker pull ghcr.io/manykarim/rf-mcp-vnc:latest      # X11 desktop over VNC/noVNC
docker run -p 8000:8000 -p 8001:8001 -p 5900:5900 -p 6080:6080 ghcr.io/manykarim/rf-mcp-vnc:latest

Headless bündelt Chromium, Firefox ESR und die Playwright-Browser. VNC-Ports: 8000 (MCP HTTP), 8001 (Frontend), 5900 (VNC), 6080 (noVNC – http://localhost:6080/vnc.html).

In Coding-Agenten registrieren

robotmcp list                              # supported agents + what's detected/registered
robotmcp install                           # interactive: registers into detected agents
robotmcp install --agents claude-code,codex,gemini
robotmcp install --agents all --scope user
robotmcp install --dry-run                 # show the plan, write nothing
robotmcp uninstall                         # safe, reversible removal

Unterstützte Agenten (jeder in seiner eigenen Datei/Format geschrieben, andere MCP-Server bleiben erhalten): Claude Code, OpenAI Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose, Cursor (plus pi, als geplant gelistet, bis seine Konfigurationskonvention bestätigt ist).

Nutzt die Umgebung deines Projekts. Installiere in ein Projekt, das eine eigene eingerichtete Umgebung hat (uv, poetry, pdm, pipenv, rye, hatch oder ein einfaches .venv), und rf-mcp wird so verdrahtet, dass es gegen diese Umgebung läuft – es sieht also die Bibliotheken, Keywords und Ressourcen deines Projekts, nicht nur die gebündelten. Es startet den aufgelösten Befehl und verifiziert, dass deine Bibliotheken erreichbar sind, bevor es die Konfiguration schreibt; ein blinder oder defekter Befehl wird abgelehnt. Eine globale uvx-/uv tool-Installation bedient weiterhin jedes Projekt ohne projektspezifische Einrichtung. Zeige mit -C <dir> darauf, optiere mit --into-project in die Installation von rf-mcp in die Projektumgebung, und führe robotmcp doctor --project-dir <dir> aus, um zu sehen, welche deiner Bibliotheken der Start erreicht.

Umfang. Installationen standardmäßig mit --scope project (schreibt in das aktuelle Projekt, z. B. ./.mcp.json), wo der Agent das unterstützt; verwende --scope user für eine globale (Home-Verzeichnis-) Installation. goose unterstützt nur den Benutzerbereich; GitHub Copilot nur den Projektbereich.

Sicher & umkehrbar. Jede Änderung wird in einem hash-verfolgten Manifest aufgezeichnet (~/.local/state/robotmcp/install-manifest.json). robotmcp uninstall entfernt nur Einträge, die seit der Installation unverändert sind – ein manuell bearbeiteter Eintrag bleibt erhalten und wird gemeldet, und fremde Server werden nie angefasst. Lieber die Konfiguration selbst bearbeiten? Füge { "mcpServers": { "robotmcp": { "command": "robotmcp" } } } hinzu.

🔌 Bibliotheks-Plugins

Erweitere RobotMCP mit benutzerdefinierten Bibliotheken über das Plugin-System. Zwei Entdeckungsmodi sind verfügbar:

• Einstiegspunkte (robotmcp.library_plugins) für verpackte Plugins.

• Manifestdateien (JSON) unter .robotmcp/plugins/ für Workspace-Überschreibungen.

Siehe die Anleitung zur Bibliotheks-Plugin-Erstellung für detaillierte Anweisungen und erkunde das Beispiel-Plugin in examples/plugins/sample_plugin, um schnell loszulegen.

🖥️ Frontend-Dashboard

RobotMCP wird mit einem optionalen Django-basierten Dashboard geliefert, das aktive Sitzungen, Keywords und Tool-Aktivitäten spiegelt.

1. Frontend-Extras installieren

   pip install rf-mcp[frontend]

2. MCP-Server mit aktiviertem Frontend starten

   uv run -m robotmcp.server --with-frontend

   • Standard-URL: http://127.0.0.1:8001/

   • Schnelle Umschalter: --frontend-host, --frontend-port, --frontend-base-path

   • Umgebungsäquivalente: ROBOTMCP_ENABLE_FRONTEND=1, ROBOTMCP_FRONTEND_HOST, ROBOTMCP_FRONTEND_PORT, ROBOTMCP_FRONTEND_BASE_PATH, ROBOTMCP_FRONTEND_DEBUG

3. Verbinde deinen MCP-Client (Cline, Claude Desktop usw.) mit demselben Serverprozess – das Dashboard streamt automatisch Ereignisse, sobald die Sitzung aktiv ist.

Um das Dashboard für einen bestimmten Lauf zu deaktivieren, lasse entweder das Flag weg oder übergib --without-frontend.

📋 Anweisungsvorlagen

RobotMCP sendet serverseitige Anweisungen an LLMs über die MCP-initialize-Antwort und leitet sie an, Keywords zu entdecken, bevor sie ausgeführt werden. Das reduziert fehlgeschlagene Tool-Aufrufe und verschwendete Tokens erheblich, besonders bei kleineren LLMs.

Konfiguration

Drei Umgebungsvariablen steuern das Anweisungsverhalten:

Ausgabe & Protokollierung. Der MCP-stdio-Kanal (stdout) trägt nur JSON-RPC; alle Logs und ein einzeiliges Bereitschaftsbanner gehen an stderr. Die Protokollierung ist standardmäßig auf WARNING gesetzt, damit der Client nicht überflutet wird – setze ROBOTMCP_LOG_LEVEL=INFO/DEBUG, um Fehler zu beheben. Die Protokollierung blockiert nie die Ausführung (sie wird auf einem Hintergrund- Thread mit Drop-on-Overflow abgearbeitet), und fd 1 wird nie unter dem Transport umgeleitet.

Integrierte Vorlagen

Beispiel

{
  "servers": {
    "robotmcp": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "-m", "robotmcp.server"],
      "env": {
        "ROBOTMCP_INSTRUCTIONS": "default",
        "ROBOTMCP_INSTRUCTIONS_TEMPLATE": "detailed"
      }
    }
  }
}

Benutzerdefinierte Anweisungen

Setzen Sie ROBOTMCP_INSTRUCTIONS=custom und stellen Sie eine Datei über ROBOTMCP_INSTRUCTIONS_FILE bereit. Benutzerdefinierte Dateien unterstützen die Platzhalter-Substitution {available_tools}. Erlaubte Erweiterungen: .txt, .md, .instruction, .instructions. Wenn die Datei fehlt oder die Validierung fehlschlägt, fällt der Server automatisch auf die standard-Vorlage zurück.

Die vollständige Anleitung finden Sie unter docs/INSTRUCTION_TEMPLATES_GUIDE.md.

🪝 Debug-Attach-Brücke

https://github.com/user-attachments/assets/8d87cd6e-c32e-4481-9f37-48b83f69f72f

RobotMCP wird mit robotmcp.attach.McpAttach ausgeliefert, einer leichtgewichtigen Robot-Framework-Bibliothek, die den Live-ExecutionContext über eine Localhost-HTTP-Brücke bereitstellt. Wenn Sie eine Suite aus VS Code (RobotCode) oder einer anderen IDE debuggen, ermöglicht die Brücke RobotMCP, die In-Process-Variablen, Importe und die Keyword-Suchreihenfolge wiederzuverwenden, anstatt einen separaten Kontext zu erstellen.

MCP-Server-Einrichtung

Beispielkonfiguration mit übergebenen Umgebungsvariablen für die Debug-Brücke

Mit UV

{
  "servers": {
    "RobotMCP": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "src/robotmcp/server.py"],
      "env": {
        "ROBOTMCP_ATTACH_HOST": "127.0.0.1",
        "ROBOTMCP_ATTACH_PORT": "7317",
        "ROBOTMCP_ATTACH_TOKEN": "change-me",
        "ROBOTMCP_ATTACH_DEFAULT": "auto"
      }
    }
  }
}

Mit Docker

{
  "servers": {
    "RobotMCP": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "ghcr.io/manykarim/rf-mcp:latest", "uv", "run", "robotmcp"],
      "env": {
        "ROBOTMCP_ATTACH_HOST": "127.0.0.1",
        "ROBOTMCP_ATTACH_PORT": "7317",
        "ROBOTMCP_ATTACH_TOKEN": "change-me",
        "ROBOTMCP_ATTACH_DEFAULT": "auto"
      }
    }
  }
}

Robot-Framework-Einrichtung

Importieren Sie die Bibliothek und starten Sie die Serve-Schleife in der Suite, die Sie debuggen:

*** Settings ***
Library    robotmcp.attach.McpAttach    token=${DEBUG_TOKEN}

*** Variables ***
${DEBUG_TOKEN}    change-me

*** Test Cases ***
Serve From Debugger
    MCP Serve    port=7317    token=${DEBUG_TOKEN}    mode=blocking    poll_ms=100
    [Teardown]    MCP Stop

• MCP Serve port=7317 token=${TOKEN} mode=blocking|step poll_ms=100 — startet den HTTP-Server (falls er nicht läuft) und verarbeitet Brückenbefehle. Verwenden Sie mode=step während der Ausführung des Keyword-Rumpfs, um genau eine anstehende Anfrage zu verarbeiten.

• MCP Stop — signalisiert der Serve-Schleife, zu beenden (wird aus der Suite oder remote über RobotMCP attach_stop_bridge verwendet).

• MCP Process Once — verarbeitet eine einzelne anstehende Anfrage und kehrt sofort zurück; nützlich, wenn die Suite zwischen Testaktionen abfragt.

• MCP Start — Alias für MCP Serve aus Gründen der Abwärtskompatibilität.

Die Brücke bindet standardmäßig an 127.0.0.1 und erwartet, dass Clients das gemeinsame Token im X-MCP-Token-Header senden.

RobotMCP für Attach konfigurieren

Starten Sie robotmcp.server mit Attach-Routing, indem Sie die Brückenverbindungsdaten über Umgebungsvariablen bereitstellen (das Token muss mit der Suite übereinstimmen):

export ROBOTMCP_ATTACH_HOST=127.0.0.1
export ROBOTMCP_ATTACH_PORT=7317          # optional, defaults to 7317
export ROBOTMCP_ATTACH_TOKEN=change-me    # optional, defaults to 'change-me'
export ROBOTMCP_ATTACH_DEFAULT=auto       # auto|force|off (auto routes when reachable)
export ROBOTMCP_ATTACH_STRICT=0           # set to 1/true to fail when bridge is unreachable
uv run python -m robotmcp.server

Wenn ROBOTMCP_ATTACH_HOST gesetzt ist, versuchen execute_step(..., use_context=true) und andere kontextbewusste Tools zunächst, innerhalb der Live-Debug-Sitzung ausgeführt zu werden. Verwenden Sie die neuen MCP-Tools, um die Brücke von jedem Agenten aus zu verwalten:

• attach_status — meldet Konfiguration, Erreichbarkeit und Diagnosen von der Brücke (/diagnostics).

• attach_stop_bridge — sendet einen /stop-Befehl, der wiederum MCP Stop in der debuggeten Suite auslöst.

🎪 Beispiel-Workflows

🌐 Webanwendungs-Tests (BDD)

Prompt:

Use RobotMCP to create a test suite and execute it step wise.
It shall:

- Open https://demoshop.makrocode.de/
- Add item to cart
- Assert item was added to cart
- Add another item to cart
- Assert another item was added to cart
- Checkout
- Assert checkout was successful

Execute step by step and build final test suite afterwards
Create in BDD style and use Keywords with embedded arguments when applicable

Ergebnis: BDD-Stil-Robot-Framework-Testsuite mit Given/When/Then-Keywords, eingebetteten Argumenten und extrahierten Variablen.

🌐 Webanwendungs-Tests (datengesteuert)

Prompt:

Use RobotMCP to create a test suite and execute it step wise.
It shall:

- Open https://saucedemo.com
- Login with different user/password combinations
- Assert message or login

Execute step by step and build final test suite afterwards
Create in datadriven style and add multiple test rows with different scenarios
Use Test Template setting in suite

Ergebnis: Datengesteuerte Robot-Framework-Testsuite mit Test Template und parametrisierten Zeilen für jedes Anmeldeszenario.

📱 Mobile-App-Tests

Prompt:

Use RobotMCP to create a TestSuite and execute it step wise.
It shall:
- Launch app from tests/appium/SauceLabs.apk
- Perform login flow
- Add products to cart
- Complete purchase

Appium server is running at http://localhost:4723
Execute the test suite stepwise and build the final version afterwards.

Ergebnis: Mobile Testsuite mit AppiumLibrary-Keywords und Gerätefunktionen.

🔌 API-Tests

Prompt:

Read the Restful Booker API documentation at https://restful-booker.herokuapp.com.
Use RobotMCP to create a TestSuite and execute it step wise.
It shall:

- Create a new booking
- Authenticate as admin
- Update the booking
- Delete the booking
- Verify each response

Execute the test suite stepwise and build the final version afterwards.

Ergebnis: API-Testsuite mit RequestsLibrary und ordnungsgemäßer Fehlerbehandlung.

🧪 XML-/Datenbank-Tests

Prompt:

Create a xml file with books and authors.
Use RobotMCP to create a TestSuite and execute it step wise.
It shall:
- Parse XML structure
- Validate specific nodes and attributes
- Assert content values
- Check XML schema compliance

Execute the test suite stepwise and build the final version afterwards.

Ergebnis: XML-Verarbeitungstest mit der XML-Bibliothek von Robot Framework.

🔍 MCP-Tools

rf-mcp stellt seine Fähigkeiten dem Agenten als MCP-Tools zur Verfügung, gruppiert nach Zweck: Planung & Orchestrierung, Sitzung & Ausführung, Erkennung & Dokumentation, Beobachtbarkeit & Diagnose, Suite-Lebenszyklus, Locator-Anleitung, visuelle Validierung und optionaler persistenter Speicher.

Vollständige Referenz: docs/MCP_TOOLS.md — jedes Tool mit seinen Parametern, Rückgabewerten und wann man es verwenden sollte. Ihr Agent liest diese Beschreibungen direkt; Sie müssen sie selten von Hand aufrufen.

🧪 BDD- und datengesteuerte Testgenerierung

BDD-Stil (Given/When/Then)

Prompt:

Use RobotMCP to create a test suite and execute it step wise.
It shall:

- Open https://demoshop.makrocode.de/
- Add item to cart
- Assert item was added to cart
- Add another item to cart
- Assert another item was added to cart
- Checkout
- Assert checkout was successful

Execute step by step and build final test suite afterwards
Create in BDD style and use Keywords with embedded arguments when applicable

Ergebnis: RobotMCP führt jeden Schritt aus, inspiziert das DOM zwischen Aktionen und generiert eine Suite im BDD-Stil mit Given/When/Then-Keywords:

*** Test Cases ***
Demoshop BDD Purchase Workflow
    Given the demoshop is open
    When the user adds the first product to cart
    Then the cart should contain 1 item
    When the user adds the second product to cart
    Then the cart should contain 2 items
    When the user proceeds to checkout
    And the user fills in the checkout form
    And the user places the order
    Then the order confirmation should be displayed

*** Keywords ***
the demoshop is open
    New Browser    chromium
    New Context
    New Page    ${DEMOSHOP_URL}

the user adds the first product to cart
    Click    ${FIRST_PRODUCT_BUTTON}

Verwenden Sie während der schrittweisen Ausführung bdd_group und bdd_intent auf execute_step, um zu steuern, wie Schritte zu Verhaltens-Keywords gruppiert werden. Rufen Sie am Ende build_test_suite(bdd_style=True) auf.

Datengesteuerte Vorlagen

Prompt:

Use RobotMCP to create a test suite and execute it step wise.
It shall:

- Open https://saucedemo.com
- Login with different user/password combinations
- Assert message or login

Execute step by step and build final test suite afterwards
Create in datadriven style and add multiple test rows with different scenarios
Use Test Template setting in suite

Ergebnis: RobotMCP erstellt eine parametrisierte Suite mit Test Template und benannten Datenzeilen:

*** Settings ***
Library         Browser
Test Template   Verify Login

*** Test Cases ***          USERNAME            PASSWORD        EXPECTED
Valid User                  standard_user       secret_sauce    Products
Locked Out User             locked_out_user     secret_sauce    locked out
Invalid Password            standard_user       wrong_pass      Username and password do not match

Verwenden Sie manage_session(action="start_test", template="Verify Login"), um das Template-Keyword zu setzen, und dann manage_session(action="add_data_row", test_name="Valid User", args=["standard_user", "secret_sauce", "Products"]), um jede Zeile hinzuzufügen.

🧠 Optimierung für kleine LLMs

RobotMCP enthält Optimierungen für kleine und mittelgroße LLMs (8K-32K-Kontextfenster), die den Token-Overhead reduzieren und die Genauigkeit von Tool-Aufrufen verbessern.

Dynamische Tool-Profile

Steuern Sie, welche Tools dem LLM basierend auf der Workflow-Phase angezeigt werden. Kleinere Modelle sehen weniger, kompaktere Tools:

manage_session(action="set_tool_profile", tool_profile="browser_exec")

Profile: browser_exec, api_exec, discovery, minimal_exec, full. Reduziert den Overhead der Tool-Beschreibungen von ~7.000 auf ~1.000 Token. Kann auch über die Umgebungsvariable ROBOTMCP_TOOL_PROFILE gesetzt werden.

Antwort-Ausführlichkeit

Steuern Sie den Detailgrad der Antworten, um den Token-Verbrauch zu reduzieren. Bei den meisten Tools über den Parameter detail_level verfügbar:

• minimal – Nur wesentliche Ausgabe (60-80 % Token-Reduzierung)

• standard – Ausgewogene Ausgabe (Standard)

• full – Vollständige detaillierte Ausgabe

Legen Sie einen Standard über ROBOTMCP_OUTPUT_VERBOSITY=compact|standard|verbose fest.

Delta-State-Antworten

get_session_state unterstützt inkrementelle Antworten, die nur Abschnitte zurückgeben, die sich seit dem letzten Aufruf geändert haben:

# First call returns full state (version 1):
get_session_state(session_id="...", sections=["variables", "page_source"])

# Subsequent calls return only what changed:
get_session_state(session_id="...", mode="delta", since_version=1)

In mode="auto" (dem Standard) gibt der Server automatisch Delta-Antworten zurück, wenn eine frühere Version existiert. Dies reduziert den Token-Verbrauch um 50-80 % bei mehrstufigen Workflows, bei denen sich zwischen den Schritten nur Variablen oder Seiteninhalte ändern.

Artefakt-Externalisierung

Große Ausgaben (HTML-Seitenquellcode, Ausführungsprotokolle, Stack-Traces) werden automatisch in abrufbare Artefakte externalisiert, anstatt in die Antwort eingebettet zu werden:

# Response includes artifact_id instead of full content:
{"result": "...", "artifact_id": "abc123", "artifact_hint": "Full page source available via fetch_artifact"}

# Fetch when needed:
fetch_artifact(artifact_id="abc123")

Dies hält Tool-Antworten kompakt, während der Zugriff auf die vollständige Ausgabe bei Bedarf erhalten bleibt.

Intent-Aktion

Das Tool intent_action bietet einen bibliotheksunabhängigen Einstiegspunkt für häufige Testaktionen. Anstatt vom LLM zu verlangen, bibliotheksspezifische Keyword-Namen und Locator-Syntax zu kennen, drückt es eine Absicht aus:

intent_action(intent="click", target="text=Login", session_id="...")
intent_action(intent="fill", target="#username", value="testuser", session_id="...")

Der Server löst Absicht + Ziel in das korrekte Keyword- und Locator-Format für die aktive Bibliothek der Sitzung auf (Browser, SeleniumLibrary oder AppiumLibrary).

Navigate-Fallback

Wenn intent_action(intent="navigate") fehlschlägt, weil kein Browser oder keine Seite geöffnet ist, öffnet der Server automatisch den Browser/die Seite und versucht es erneut:

• Browser-Bibliothek: führt New Browser + New Page aus (oder nur New Page, wenn der Browser existiert)

• SeleniumLibrary: führt Open Browser about:blank chrome aus

Die Antwort enthält fallback_applied: true und die Anzahl der fallback_steps. Spart 2-4 Tool-Aufrufe pro Sitzung.

Batch-Ausführung

Das Tool execute_batch führt mehrere Keywords in einem einzigen MCP-Aufruf aus und reduziert N Round-Trips auf 1. Schritte können über ${STEP_N}-Variablen auf Ergebnisse früherer Schritte verweisen:

execute_batch(session_id="...", steps=[
    {"keyword": "Go To", "args": ["https://example.com"]},
    {"keyword": "Get Title", "assign_to": "title"},
    {"keyword": "Should Be Equal", "args": ["${STEP_2}", "Example Domain"]}
], on_failure="recover")

Wenn ein Schritt fehlschlägt, können Sie mit resume_batch Korrekturschritte einfügen und ab dem Fehlerpunkt erneut versuchen.

Strict-Mode-Hinweise

Wenn ein Browser-Bibliotheks-Keyword fehlschlägt, weil der Selektor mehrere Elemente abgleicht (Playwright-Strict-Mode), enthält die Fehlerantwort einen Hinweis, der >> nth=0 (nullbasierter Index) oder >> visible=true-Selektorketten vorschlägt, mit konkreten Beispielen unter Verwendung des tatsächlichen Keyword-Namens und der Elementanzahl.

Typ-gebundene Parameter

Alle Aktions-/Modus-/Strategie-Parameter verwenden Literal-Typen, die enum-Einschränkungen im JSON-Schema erzeugen. Dies eliminiert halluzinierte Werte (z. B. action="setup" statt action="init"). Alle Werte akzeptieren Groß-/Kleinschreibung-unabhängige Eingaben.

Automatische Parameter-Koerzion

Häufige Fehler kleiner LLMs werden serverseitig korrigiert:

• JSON-stringifizierte Arrays ("[\"Browser\"]") werden in native Arrays geparst

• Kommagetrennte Zeichenfolgen ("Browser,BuiltIn") werden in Listen aufgeteilt

• Veraltete Keywords (GET) werden auf aktuelle Entsprechungen (GET On Session) abgebildet

Anweisungsvorlagen

Konfigurierbare Anweisungen auf Serverebene führen LLMs dazu, dem Muster „Erst entdecken, dann handeln" zu folgen. Wählen Sie eine Vorlage, die auf die Fähigkeiten Ihres LLM abgestimmt ist — von minimal (~40 Token) für Claude Opus bis detailed (~600 Token) für Claude Haiku. Siehe Anweisungsvorlagen oben.

🧠 Persistenter semantischer Speicher

RobotMCP kann aus früheren Sitzungen lernen und erfolgreiche Muster, Locators und Fehlerbehebungen abrufen — wodurch Trial-and-Error bei wiederholten Testszenarien reduziert wird.

So funktioniert es

Der Speicher wird von sqlite-vec (Vektorsuche) und model2vec (256-dimensionale Embeddings) unterstützt. Wenn aktiviert, führt der Server Folgendes aus:

1. Speichert erfolgreiche Schrittfolgen, funktionierende Locators und Fehler→Behebungs-Zuordnungen nach jedem Tool-Aufruf

2. Ruft relevante Erinnerungen ab und injiziert sie als Hinweise in Tool-Antworten (z. B. enthalten execute_step-Fehler frühere Behebungen, get_session_state enthält zuvor erfolgreiche Schrittmuster)

3. Lernt über Sitzungen hinweg — die warme Datenbank bleibt zwischen Server-Neustarts erhalten

Installation

pip install rf-mcp[memory]
# or
uv pip install rf-mcp[memory]

Konfiguration

Aktivieren Sie über Umgebungsvariablen:

{
  "servers": {
    "robotmcp": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "-m", "robotmcp.server"],
      "env": {
        "ROBOTMCP_MEMORY_ENABLED": "true",
        "ROBOTMCP_MEMORY_DB_PATH": "./memory.db"
      }
    }
  }
}

MCP-Tools für den Speicher

Wenn der Speicher aktiviert ist, werden fünf zusätzliche Tools verfügbar:

Antwort-Anreicherung

Speicherhinweise werden automatisch in vorhandene Tool-Antworten injiziert — keine LLM-Mitarbeit erforderlich:

• execute_step-Fehler: Frühere Behebungen und funktionierende Locators sind in der Fehlerantwort enthalten

• get_session_state: Zuvor erfolgreiche Schrittmuster für das Szenario sind enthalten

• analyze_scenario: Abgerufene Schrittfolgen aus früheren Sitzungen werden vorgeschlagen

Alle Speicherabrufe haben ein 50-ms-Timeout, um die Antwortlatenz nicht zu beeinträchtigen.

Benchmark-Ergebnisse

Getestet über 8 Szenarien (72 opencode-Aufrufe, jeweils 3 Iterationen) mit qwen/qwen3-coder:

Speichervorteile sind am stärksten bei komplexen, mehrstufigen Szenarien, in denen frühere Locators und Schrittsequenzen explorative Tool-Aufrufe reduzieren.

⚙️ Konfiguration

rf-mcp läuft mit sinnvollen Standardeinstellungen; wenn Sie es anpassen müssen, ist alles über eine Umgebungsvariable erreichbar – Anweisungsvorlagen, die Attach-Brücke, Ausgabe-/Token-Ökonomie, Speicher, das Frontend-Dashboard, PlatynUI-Desktop-Sicherheit und mehr.

Vollständige Referenz: docs/CONFIGURATION.md – jede ROBOTMCP_*-Variable mit ihren akzeptierten Werten und Standardwerten, plus die robotmcp-CLI-Flags und Unterbefehle.

🤝 Mitwirken

1. Forken Sie das Repository

2. Klonen Sie Ihren Fork lokal

3. Installieren Sie die Entwicklungsabhängigkeiten: uv sync

4. Erstellen Sie einen Feature-Branch

5. Fügen Sie umfassende Tests für neue Funktionen hinzu

6. Führen Sie Tests aus: uv run pytest tests/

7. Reichen Sie einen Pull-Request ein

📝 Änderungsprotokoll

• v0.34.0 – Native Desktop-Automatisierung (rf-mcp[desktop], PlatynUI, Windows-bereit); projektbewusster Installer, der die eigenen Bibliotheken Ihres Projekts verwendet; schlankere Agent-Anweisungen; Behebungen von Cold-Start-Hänger, Windows-Dry-Run-Deadlock und generierten Suite-Pfaden; Tool-Profile auf FastMCP 3 wiederhergestellt

• v0.31.1 – Paketbereinigung (Tests/Beispiele aus sdist ausschließen)

• v0.31.0 – BDD/datengesteuerte Generierung, Behebungen der Namespace-Architektur, persistenter Speicher, 71-88% Token-Reduktion

• v0.30.1 – FastMCP 3.x-Kompatibilitätsschicht

• v0.30.0 – Optimierung für kleine LLMs (Tool-Profile, Intent-Aktion, Antwortoptimierung, Typbeschränkungen)

• v0.29.0 – Anweisungsvorlagen, Multi-Test-Sitzungen, Batch-Ausführung, intelligente Timeouts

📄 Lizenz

Apache-2.0-Lizenz – siehe LICENSE-Datei für Details.

⭐ Geben Sie uns einen Stern auf GitHub, wenn RobotMCP Ihre Testautomatisierungsreise unterstützt!

Mit ❤️ gemacht für die Robot-Framework- und KI-Automatisierungs-Community.