🤖 RobotMCP – KI-gestützte Brücke für Testautomatisierung

Einfaches Englisch hinein, echte Robot-Framework-Tests heraus – während ein KI-Agent das Tippen übernimmt.

RobotMCP (rf-mcp) ist ein Model Context Protocol (MCP)-Server, der deinem Coding-Agenten die Schlüssel zu Robot Framework übergibt. 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 bestanden sind – eine saubere .robot-Suite. Keine geratenen Locators, keine halluzinierten Keywords, kein „Bei mir funktioniert's“. Auf Basis von Robot Framework gebaut: Open Source und ständig in Weiterentwicklung.

Neu bei rf-mcp? Spring zu Getting Started. Du willst das ganze Bild? Sieh dir die MCP-Tool-Referenz, Konfiguration und ausgearbeitete Beispiele an.

📺 Video-Tutorial

Intro

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

✨ Schnellstart

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

1️⃣ Als Tool installieren

# 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 zu deinem PATH hinzugefügt. Extras entscheiden, welche Testbibliotheken mitkommen – siehe die Tabelle der Extras 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 passende MCP-Konfiguration für Claude Code, Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose und Cursor – jeweils im eigenen 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 beim Installieren vor. Ohne diesen Schalter kostet der erste Serverstart nach einer Installation/einem Update mehrere Sekunden .pyc-Kompilierung, bevor der MCP-Handshake abgeschlossen ist (manchen Clients läuft die Zeit davon und zeigt den Server als nicht verfügbar an). Das ist ein einmaliger Kostenpunkt zum Zeitpunkt der Installation.

HTTP

Starte den MCP-Server mit HTTP-Transport:

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

Danach konfigurierst du deinen KI-Agenten:

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

Claude Code

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

3️⃣ Mit dem Testen beginnen – 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 schon. rf-mcp führt den Agenten durch Discovery, Live-Ausführung und Suite-Erstellung – du beschreibst einfach den Test.

Related MCP server: RobotMCP

📚 Dokumentation

✏️ Installation

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

Extras

Die Extras bestimmen, welche Robot-Framework-Bibliotheken mitkommen:

Für gerne widersprüchlich, Browser Library braucht auch Playwright-Browser – führe robotmcp init --browsers (oder rfbrowser init) einmal aus, und zwar innerhalb der eigenen Umgebung von rf-mcp. 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

Vorab erstellte Images (Headless für CI, zzgl. elf 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 (jeweils in eigener Datei/eigenem Format geschrieben, andere MCP-Server bleiben erhalten): Claude Code, OpenAI Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose, Cursor (sowie pi, gelistet als geplant, bis dessen Konfigurationskonvention bestätigt ist).

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

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

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

🔌 Library-Plugins

Erweitere RobotMCP um benutzerdefinierte Bibliotheken über das Plugin-System. Zwei Erkennungsmodi stehen zur Verfügung:

• Entry Points (robotmcp.library_plugins) für gepackte Plugins.

• Manifest-Dateien (JSON) unter .robotmcp/plugins/ für Workspace-Overrides.

Details und Anleitung im Library-Plugin-Author-Guide und zum schnellen Einstieg das Beispiel-Plugin in examples/plugins/sample_plugin erkunden.

🖥️ Frontend-Dashboard

RobotMCP bringet ein optionales Django-basiertes Dashboard mit, das aktive Sessions, Keywords und Tool-Aktivität spiegelt.

1. Frontend-Extras installieren

   pip install rf-mcp[frontend]

2. Starte den MCP-Server mit aktiviertem Frontend

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

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

   • Schnelle Schalter: --frontend-host, --frontend-port, --frontend-base-path`

   • Entsprechende Umgebungsvariablen: 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 Session aktiv ist.

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

📋 Anweisungsvorlagen

Robot hat rmcp server-level instructions an LLMs über die MCP initialize-Antwort gesendet, damit diese Keywords entdecken, bevor sie sie ausführen. Das reduziert fehlgriffe und verschwendete Tokens deutlich, besonders bei kleineren LLMs.

Automatisches (Automated)

Drei Umgebungsvariablen steuern das Verhalten der Anweisungen:

Shell. Ausgabe & Logging. Der MCP stdio-Kanal (stdout) trägt nur JSON-RPC; alle Logs und eine einzeilige readiness-Banner gehen auf stderr. Logging standardisiert Inference auf WARNING, damit der Client nicht überflutet wird – setze ROBOTMCP_LOG_LEVEL=INFO/DEBUG für Troubleshooting. Logging blockiert nie die Ausführung (es wird auf einem Hintergrundthread mit Drop-bei-Überlauf entleert), und fd 1 wird nie unter dem Transport umgeleitet.

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 Bridge

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

RobotMCP wird mit robotmcp.attach.McpAttach geliefert, einer schlanken Robot-Framework-Bibliothek, die den live ExecutionContext über eine HTTP-Brücke auf localhost bereitstellt. Wenn Sie eine Suite aus VS Code (RobotCode) oder einer anderen IDE debuggen, ermöglicht die Brücke RobotMCP, die In-Process-Variablen, Imports und die Keyword-Suchreihenfolge wiederzuverwenden, statt einen separaten Kontext zu erstellen.

MCP-Server-Einrichtung

Beispielkonfiguration mit übergebenen Umgebungsvariablen für die Debug Bridge

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 innerhalb 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 Bridge-Befehle. Verwenden Sie mode=step während der Ausführung des Keyword-Body, um genau eine anstehende Anforderung zu verarbeiten.

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

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

• 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 Header X-MCP-Token senden.

RobotMCP für das Attach konfigurieren

Starten Sie robotmcp.server mit Attach-Routing, indem Sie die Verbindungsdaten der Brücke ü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 kontextbezogene Tools zuerst, innerhalb der Live-Debug-Sitzung zu laufen. Verwenden Sie die neuen MCP-Tools, um die Brücke von einem beliebigen Agenten zu verwalten:

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

• attach_stop_bridge — sendet einen /stop-Befehl, der wiederum MCP Stop in der gedebugten 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 Login-Szenario.

📱 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ätefähigkeiten.

🔌 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äßem 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 legt seine Fähigkeiten dem Agenten über MCP-Tools dar, gruppiert nach Zweck: Planung & Orchestrierung, Sitzung & Ausführung, Entdeckung & Dokumentation, Beobachtbarkeit & Diagnostik, Suite-Lebenszyklus, Locator-Führung, visuelle Validierung und optionales persistentes Gedächtnis.

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

🧪 BDD- und datengetriebene 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,ntersucht das DOMSTeinDOM zwischen den Aktionen und bringt eine BDD-Style-Suite mit Given/When/Then-Keywords hervor:

*** 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}

Bei der schrittweisen Ausführung verwenden Sie bdd_group und bdd_intent an execute_step, um zu steuern, wie Schritte zu verhaltensbezogenen 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 baut 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

Legen Sie mit manage_session(action="start_test", template="Verify Login") das Template-Keyword fest, danach fügen Sie mit manage_session(action="add_data_row", test_name="Valid User", args=["standard_user", "secret_sauce", "Products"]) jede Zeile hinzu.

🧠 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-Aufrufungen verbessern.

Dynamische Tool-Profile

Steuern Sie je nach Workflow-Phase, welche Tools für das LLM sichtbar sind. Kleinere Modelle sehen weniger, kompaktere Tools:

Gerekopf

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

Profil: browser_exec, api_exec, discovery, minimal_exec, full. Reduziert den Beschreibungsaufwand der Tools von ~7,000 auf ~1,000 Tokens. Dies kann auch über die Umgebungsvariable ROBOTMCP_TOOL_PROFILE gesetzt werden.

Antwortgrad

Steuern Sie die Detailgenauigkeit der Antworten, um Token zu sparen. Auf den meisten Tools über den Parameter detail_level verfügbar:

• minimal – Nur wesentliche Ausgabe (60–80 % weniger Tokens)

• standard – Ausgewogene Ausgabe (Standard)

• full – Vollständige detaillierte Ausgabe

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

Statusänderungs-Antworten

get_session_state unterstützt inkrementelle Antworten, die nur die 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)

Im Modus mode="auto" (die Standardeinstellung) liefert der Server automatisch Delta-Antworten, wenn eine vorherige Version existiert. Dies reduziert den Token-Verbrauch um 50–80 % bei mehrschrittigen Workflows, wo sich zwischen den Schritten nur Variablen oder Seiteninhalte ändern.

Auslagerung von Artefakten

Ausführungsprotokolle, Stack-Traces, also große Ausgaben (HTML-Seitenquelle, Logs, Stack-Traces), werden automatisch in abrufbare Artefakte ausgelagert, anstatt in der Antwort eingebettet:

# 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")

Dadurch bleiben Tool-Antworten kompakt, während der Zugriff auf die vollständigeAusgabe bei Bedarf erhalten bleibt.

Absichtsaktion (Intent Action)

Das Tool intent_action bietet einen bibliotheksunabhängigen Einstiegspunkt für häufig Aktionen. Statt das LLM bibliotheksspezifische Keyword-Namen und Locator-Syntax kennen zu müssen, 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).

Navigations-Fallback

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

• Browser-Bibliothek – New Browser + New Page (oder nur New Page, wenn der Browser bereits existiert)

• SeleniumLibrary – Open Browser about:blank chrome

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

Batch-Ausführung

Das Tool execute_batch führt mehrere Keywörterder in einem einzigen MCP-Aufruf aus und reduziert erst N Round-Trips auf 1. Schritte können über ${STEP_N}-Verweise auf Ergebnisse vorheriger Schritte zugreifen:

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 Fehlerbehandelungsschritte einfügen und ab der Fehlerstelle erneut versuchen.

Strict-Mode-Hinweise

Wenn ein Browser-Library-Keyword fehlschlägt, weil der Selektor mehrere Elemente findet (Playwright strict mode), wird in derFehlerempfandahlt Antworte: Hinweis wie >> nth=0(nullbasierter Index) oder>> visible=true`-Selektor-Verkettung mit konkreten Beispielen und Einsatz des tatsächlichen Keyword-Namens und der Elementanzahl.

Typparameterconstrained-Konstanten

Alle Aktions-/Modi-/Strategie-Parameter verwenden Literal-Typen und erzeugen so enum-Constraints im JSON-Schema. Damit werden halluzinierte Werte (z. B. action="setup" anstelle von action="init") ausgeschlossen. Alle Wertefunktion auch unabhängig von Groß-/Kleinschreibung.

Automatische Parameter-Coercion

Häufige kleine LLM-Fehler werden serverseitig korrigiert:

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

• Durch Kommas getrennte Zeichenfolgen ("Browser,BuiltIn") werden in Listen aufgeteilt.

• Veraltete URLs, z. B. GET, werden auf die aktuellen Entsprechungen gemappt (GET On Session).

Anweisungsvorlagen

Konfigurierbare Serveranweisungen leiten LLMs zum Muster „erst entdecken, dann handeln“. Wählen Sie eine Vorlage, geklemmt auf die Fähigkeit Ihres LLMs – von minimal (~40 Tokens) für Claude Opus bis detailed (~600 Tokens) für Claude Haiku. Siehe ...

🧠 Persistentes semantisches Gedächtnis

RobotMCP lernt aus früheren Sitzungen und ruft erfolgreiche Muster, Locators und Fehlerbehebungen ab – das reduziert Trial-and-Error bei wiederholten Testszenarien.

So funktioniert es

Das Gedächtnis wird von sqlite-vec (Vektorsuche) und model2vec (256-dimensionale Embeddings) unterstützt. Wenn aktiviert, tut der Server:

• Funktionen und Locators erfolgreicher Schritte sowie Fehler→Fix-Zuordnungen werden nach jedem Tool-Aufruf geschnitten

• Relevante Memories werden abgerufen und als Hinweise in Tool-Antworten eingefügt (z. B. enthalten execute_step-Fehler frühere Fixes, get_session_state enthält früher erfolgreiche Schrittmuster)

• Lernen über Sitzungen hinweg – die warme Datenbank bleibt zwischen Serverneustarts bestehen.

Installation

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

Einrichtung

Konfigurieren über Umgebungsvariablen:

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

Gedächtnis-MCP-Tools

Wenn das Gedächtnis aktiviert ist, stehen fünf zusätzliche Tools zur Verfügung:

Antwort-Anreicherung

Erinnerungen werden automatisch in bestehende Tool-Antworte eingebettet – keinen justierenden LLM-Eingriff erforderlich:

• execute_step-Fehler: Frühere Fixes und funktionierende Locale werden in der Fehlerantwort angezeigt.

• get_session_state: Früher erfolgreiche Schritte für das Szenario werden eingeblendet.

• analyze_scenario: Ältere, in früheren Sitzungen gefundene Schrittfolgen werden vorgeschlagen.

• Alle Gedächtnis-Abfragen haben ein 50-ms-Timeout, um die Antwort-Latenz nicht zu beeinträchtigen.

Benchmark-Ergebnisse

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

Die Speichervorteile sind bei komplexen, mehrstufigen Szenarien am größten, in denen zuvor gespeicherte Locators und Schrittfolgen die Anzahl explorativer Tool-Aufrufe reduzieren.

⚙️ Konfiguration

rf-mcp läuft mit sinnvollen Standardeinstellungen; falls du es anpassen musst, ist alles nur eine Umgebungsvariable entfernt – Instruktionsvorlagen, die Attach-Brücke, die Ausgabe-/Token-Ökonomie, der Speicher, das Frontend-Dashboard, die PlatynUI-Desktop-Sicherheit und mehr.

Vollständige Referenz: docs/CONFIGURATION.md – jede ROBOTMCP_*-Variable mit ihren zulässigen Werten und dem Standardwert sowie die CLI-Flags und Unterbefehle von robotmcp.

🤝 Mitwirken

Wir freuen uns über Beiträge! So legst du los:

1. Forke das Repository

2. Klone deinen Fork lokal

3. Installiere die Entwicklungsabhängigkeiten: uv sync

4. Erstelle einen Feature-Branch

5. Füge umfassende Tests für die neue Funktionalität hinzu

6. Führe die Tests aus: uv run pytest tests/

7. Reiche einen Pull Request ein

📝 Änderungsprotokoll

• v0.34.0 – Native Desktop-Automatisierung (rf-mcp[desktop], PlatynUI, Windows-ready); projektbewusste Installer, der die eigenen Bibliotheken deines Projekts verwendet; schlankere Agent-Anweisungen; Fehlerbehebungen für Cold-Start-Hänger, Windows-Dry-Run-Deadlocks und Pfade generierter Test-Suiten; Tool-Profile unter FastMCP 3 wiederhergestellt

• v0.31.1 – Bereinigung der Paketierung (Tests/Beispiele vom sdist ausgeschlossen)

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

• v0.30.1 – Kompatibilitätsschicht für FastMCP 3.x

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

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

📄 Lizenz

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

⭐ Gib uns einen Stern auf GitHub, wenn Robot MCP dir bei deiner Testautomatisierung hilft!

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