🤖 RobotMCP - Puente de automatización de pruebas impulsado por IA

Inglés sencillo entra, pruebas reales de Robot Framework salen — con un agente de IA encargándose del tecleo.

RobotMCP (rf-mcp) es un servidor de Model Context Protocol (MCP) que entrega a tu agente de codificación las llaves de Robot Framework. El agente descubre palabras clave, ejecuta pasos en vivo contra Browser, Selenium, Appium, Requests, una base de datos o el escritorio, ve lo que realmente sucede y — una vez que los pasos pasan — te escribe una suite .robot limpia. Nada de localizadores adivinados, ni palabras clave alucinadas, ni «en mi máquina funciona». Está construido sobre Robot Framework: open source y siempre en evolución.

¿Nuevo en rf-mcp? Salta a Primeros pasos. ¿Quieres ver el panorama completo? Consulta la referencia de herramientas MCP, la configuración y los ejemplos prácticos.

📺 Video Tutorial

Introducción

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

✨ Inicio rápido

Tres comandos y una frase. Esa es toda la configuración.

1️⃣ Instálalo como herramienta

¿Requisitos previos?

• Instala Python +v3,12

• Como administrador, instala en Powershell > winget install astral-sh.uv # Para habilitar los comandos de uv

• Instala VScode y las extensiones (GitHub Copilot y haz el inicio de sesión) # Para habilitar las terminales de agente

• Instala las extensiones de Vscode Material Icon theme, Save Typing, Dracula, Robocorp # Para habilitar Robot Framework

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

Esto coloca un comando robotmcp en tu PATH. Los extras deciden qué librerías de prueba se incluyen — consulta la tabla de extras en Instalación.

2️⃣ Conéctalo a tu agente de codificación

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

robotmcp install escribe la configuración MCP adecuada para Claude Code, Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose, y Cursor — cada uno en su propio formato, sin tocar tus otros servidores. ¿Prefieres hacerlo a mano? Todos los agentes aceptan:

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

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

UV_COMPILE_BYTECODE=1 precompila el árbol de dependencias al instalarlo. Sin ello, el primer arranque del servidor tras una instalación/actualización se lleva varios segundos compilando .pyc antes de que se complete el handshake de MCP (algunos clientes agotan el tiempo de espera y muestran el servidor como indispuesto). Es un coste único, en el momento de instalar.

HTTP

Inicia el servidor MCP con transporte HTTP:

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

A continuación, configura tu agente de IA:

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

Claude Code

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

3️⃣ Empieza a probar — solo tienes que pedirlo

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.

Eso es todo. rf-mcp guía al agente durante el descubrimiento, la ejecución en vivo y la generación de la suite — tú solo describas la prueba.

Related MCP server: robotframework-mcp

📚 Documentación

🛠️ Instalación

El inicio rápido cubre la ruta recomendada (uv tool install). Esta sección incluye la tabla de extras, y los métodos previos de instalación y el registro completo de agentes.

Extras

Los extras deciden qué librerías de Robot Framework se instalan:

Browser Library también necesita los navegadores de Playwright — ejecuta robotmcp init --browsers (o rfbrowser init) una vez, dentro del propio entorno de rf-mcp. Node.js solo se necesita para Browser.

Otros métodos de instalación

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

Imágenes preconstruidas (headless para CI, además de una imagen con VNC para depurarlo visualmente):

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

La versión headless incluye Chromium, Firefox ESR y los navegadores de Playwright. Puertos VNC: 8000 (MCP HTTP), 8001 (frontend), 5900 (VNC), 6080 (noVNC — http://localhost:6080/vnc.html).

Registrar en los agentes de codificación

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

Agentes admitidos (cada uno en su propio archivo/formato, conservando el resto de servidores MCP): Claude Code, OpenAI Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose, Cursor (además de pi, marcada como planned hasta que se confirme su convención de configuración).

Usa el entorno del proyecto. Si instalas dentro de un proyecto que tiene su propio entorno establecido (uv, poetry, pdm, pipenv, rye, hatch, o simplemente un .venv), rf-mcp se conecta para ejecutarse contra ese entorno, de modo que ve las librerías, keywords y recursos de tu proyecto, no solo los que incorpora. Ejecuta el comando resuelto y verifica que tus librerías sean accesibles antes de crear la configuración; un comando incierto o roto se rechaza. Una instalación global con uvx (o uv tool) sigue servira cualquier proyecto sin configuración adicional por proyecto. Puedes apuntarlo a un directorio con -C <dir>, optar por instalar rf-mcp en el entorno del proyecto con --into-project, y ejecutar robotmcp doctor --project-dir <dir> para ver a cuáles de tus librerías llega el lanzamiento.

Alcance. Por defecto la instalación usa --scope project (escribe en el proyecto actual, p. ej. ./.mcp.json) cuando el agente lo admite; para un instalación global (en el directorio personal) usa --scope user. goose solo admite el ámbito de usuario; GitHub Copilot solo el proyecto.

Seguro y reversible. Cada cambio queda registrado en un manifiesto controlado por hash (~/.local/state/robotmcp/install-manifest.json). robotmcp uninstall quita solo las entradas que no han cambiado desde la instalación; una entrada modificada a mano se deja intacta y se informa de ello, y lo servidores no relacionados se dejan protegidos. ¿Prefieres editar la configuración tú mismo? Añade "mcp"Servers": { "robotmcp": { "command": "robotmcp" } } } no configure.

🔌 Library Plugins

Amplía RobotMCP con librerías personalizadas a través del sistema de plugins. Puedes elegir entre dos modos de descubrimiento:

• Entry points (robotmcp.library_plugins) para plugins empaquetados.

• Archivos de manifiesto (JSON) dentro de .robotmcp/plugins/ para anular configuraciones del espacio de trabajo.

Consulta la guía de creación de plugins de librería para las instrucciones completas y explora el plugin de ejemplo en examples/plugins/sample_plugin.

🖥️ Panel de frontend

RobotMCP incluye un panel opcional basado en Django que muestra lo que ocurre en las sesiones activas, con las palabras clave y el uso de herramientas.

1. Instala los extras del frontend

   pip install rf-mcp[frontend]

2. Inicia el servidor MCP con el frontend activado

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

   • URL por defecto: http://127.0.0.1:8001/

   • Ajustes rápidos: --frontend-host, --frontend-port, --frontend-base-path

   • Equivalentes en variables de entorno: ROBOTMCP_ENABLE_FRONTEND=1, ROBOTMCP_FRONTEND_HOST, ROBOTMCP_FRONTEND_PORT, ROBOTMCP_FRONTEND_BASE_PATH, ROBOTMCP_FRONTEND_DEBUG

3. Conecta tu cliente MCP (Cline, Claude Desktop, etc.) al mismo proceso del servidor: el panel transmitirá automáticamente los eventos en cuanto la sesión esté activa.

Para desactivar el panel en una ejecución concreta, omite la opción o pasa --without-frontend.

📋 Plantillas de instrucciones

RobotMCP envía instrucciones de nivel servidor a los LLMs a través de la respuesta initialize de MCP, para que detecten las palabras clave antes de ejecutarlas. Esto reduce muy significativamente las llamadas de herramienta fallidas y las tokens desperdiciadas, sobre todo en modelos más pequeños.

Configuración

Tres variables de entorno controlan el comportamiento de las instrucciones:

Salida y registro. El canal stdio de MCP (stdout) transporta solo JSON-RPC; todos los logs y un aviso de “listo” en una línea van a stderr. Por defecto el registro es WARNING para no inundar al cliente; pon ROBOTMCP_LOG_LEVEL=INFO/DEBUG para solucionar problemas. El registro nunca bloquea la ejecución (se vacía en un hilo en segundo plano, descartando datos cuando se desborda), y el fd 1 nunca se redirige fuera del transporte.

Plantillas integradas

Ejemplo

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

Instrucciones personalizadas

Configura ROBOTMCP_INSTRUCTIONS=custom y proporciona un archivo mediante ROBOTMCP_INSTRUCTIONS_FILE. Los archivos personalizados admiten la sustitución del marcador {available_tools}. Extensiones permitidas: .txt, .md, .instruction, .instructions. Si el archivo no existe o no supera la validación, el servidor usa automáticamente la plantilla standard.

Consulta docs/INSTRUCTION_TEMPLATES_GUIDE.md para ver la guía completa.

🪝 Puente de depuración por adjunto

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

RobotMCP incluye robotmcp.attach.McpAttach, una biblioteca ligera de Robot Framework que expone el ExecutionContext en vivo a través de un puente HTTP de localhost. Cuando depuras una suite desde VS Code (RobotCode) u otro IDE, el puente permite que RobotMCP reutilice las variables, importaciones y el orden de búsqueda de palabras clave del proceso, en lugar de crear un contexto separado.

Configuración del servidor MCP

Configuración de ejemplo con variables de entorno pasadas para el puente de depuración

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

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

Configuración de Robot Framework

Importa la biblioteca y crea un bucle de servidor dentro de la suite que estás ejecutando:

*** 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 — inicia el servidor HTTP (si no está en ejecución) y procesa los comandos del puente. Usa mode=step durante la ejecución del cuerpo de una palabra clave para procesar exactamente una solicitud pendiente.

• MCP Stop — envía una señal al bucle de servicio para finalizarlo (usado desde la suite o de forma remota a través de attach_stop_bridge de RobotMCP).

• MCP Process Once — procesa una única solicitud pendiente y regresa inmediatamente; es útil cuando la suite ispollingea entre acciones de prueba.

• MCP Start — alias de MCP Serve por compatibilidad con versiones anteriores.

El puente se enlaza a 127.0.0.1 de forma predeterminada y espera que los clientes envíen el token compartido en el encabezado X-MCP-Token.

Configurar RobotMCP para la conexión

Inicia robotmcp.server con enrutamiento por conexión, proporcionando la configuración de conexión del puente mediante variables de entorno (el token debe ser el mismo que el de la suite):

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

Cuando ROBOTMCP_ATTACH_HOST está configurado, execute_step(..., use_context=true) y otras demás herramientas sensibles al contexto intentan ejecutarse primero dentro de la sesión de depuración en vivo. Usa las nuevas herramientas MCP para administrar el puente desde cualquier agente:

• attach_status — informa sobre la configuración, la accesibilidad y los diagnósticos del puente (/diagnostics).

• attach_stop_bridge — envía un comando /stop, que a su vez lanza MCP Stop en el paquete depurado.

🎪 Ejemplos de flujos de trabajo

🌐 Pruebas de aplicaciones web (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

Resultado: Conjunto de pruebas de Robot Framework en estilo BDD, con palabras clave Given/When/Then, argumentos incorporados y variables extraídas.

🌐 Pruebas de aplicaciones web (orientadas a datos)

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

Resultado: Conjunto de pruebas de Robot Framework orientado a datos, con Test Template y filas parametrizadas para cada escenario de inicio de sesión.

📱 Pruebas de aplicaciones móviles

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.

Resultado: Suite de pruebas móviles con keywords de AppiumLibrary y capacidades de dispositivo.

🔌 Pruebas de API

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.

Resultado: Conjunto de pruebas de API que utiliza RequestsLibrary con un correcto manejo de errores.

🧪 Pruebas XML/Base de datos

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.

Resultado: Prueba de procesamiento XML con la librería XML de Robot Framework.

🔍 Herramientas MCP

rf-mcp expone sus capacidades al agente como herramientas MCP, agrupadas por propósito: planificación y orquestación, sesión y ejecución, descubrimiento y documentación, observabilidad y diagnósticos, ciclo de vida de suites, guía de localizadores, validación visual y memoria persistente opcional.

Referencia completa: docs/MCP_TOOLS.md — todas las herramientas, sus parámetros, valores de retorno y cuándo utilizarlas. Tu agente lee estas descripciones directamente; rara vez necesitas llamarlas manualmente.

🧪 Generación de pruebas BDD y orientadas a datos

Estilo BDD (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

Resultado: RobotMCP ejecuta cada paso, inspecciona el DOM entre acciones y genera una suite en estilo BDD con palabras clave Given/When/Then:

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

Durante la ejecución de los pasos, usa bdd_group y bdd_intent en execute_step para controlar cómo se agrupan los pasos en palabras clave de comportamiento. Al principio de todo, llama a build_test_suite(bdd_style=True).

Plantillas orientadas a datos

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

Resultado: RobotMCP construye una suite parametrizada con Test Template y filas de datos con nombre:

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

Usa manage_session(action="start_test", template="Verify Login") para establecer la palabra clave plantilla, y luego manage_session(action="add_data_row", test_name="Valid User", args=["standard_user", "secret_sauce", "Products"]) para agregar cada fila.

🧠 Optimización para LLMs pequeños

RobotMCP incluye optimizaciones para LLMs pequeños y medianos (ventanas de contexto de 8K a 32K) que reducen el uso de tokens y mejoran la precisión de las llamadas a herramientas.

Perfiles dinámicos de herramientas

Controla qué herramientas están visibles para el LLM según la fase del flujo de trabajo. Los modelos más pequeños ven menos herramientas y más compactas:

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

Perfiles: browser_exec, api_exec, discovery, minimal_exec, full. Reduce el coste de descripción de las herramientas de ~7,000 a ~1,000 tokens. También se puede establecer mediante la variable de entorno ROBOTMCP_TOOL_PROFILE.

Nivel de detalle de la respuesta

Controla el nivel de detalle de la respuesta para reducir el consumo de tokens. Está disponible en la mayoría de las herramientas con el parámetro detail_level:

• minimal — solo la salida esencial (reducción de tokens del 60-80%)

• standard — salida equilibrada (opción por defecto)

• full — salida completa y detallada

Establece un valor predeterminado con ROBOTMCP_OUTPUT_VERBOSITY=compact|standard|verbose.

Respuestas de estado incremental

get_session_state admite respuestas incrementales que solo devuelven las secciones que han cambiado desde la última llamada:

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

En mode="auto" (el predeterminado), el servidor devuelve automáticamente respuestas delta si existe una versión anterior. Esto reduce el uso de tokens en un 50-80% en flujos de trabajo de varios pasos donde solo cambian variables o el contenido de la página entre un paso y otro.

Externalización de artefactos

Las salidas grandes (código fuente de una página HTML, registros de ejecución, trazas de pila o seguimiento de excepciones) se externalizan automáticamente como artefactos repetibles en lugar de incrustarse en la respuesta:

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

Esto mantiene las respuestas de las herramientas compactas y a la vez conserva el acceso a la salida completa cuando se necesita.

Acción por intención

La herramienta intent_action proporciona un punto de entrada independiente de la librería para acciones de prueba comunes. En lugar de exigir que el LLM conozca los nombres de palabras clave específicos de la librería y la sintaxis de localizadores, expresa la intención de la acción:

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

El servidor resuelve la intención más el destino para convertirlo en la palabra clave y el formato de localizador correctos para los marcos activos de la sesión (Browser, SeleniumLibrary o AppiumLibrary).

Reintento de navegación

Cuando intent_action(intent="navigate") falla porque no hay ningún navegador o página abierta, el servidor abre automáticamente el navegador o la página y lo reintenta:

• Browser Library: ejecuta New Browser + New Page (o solo New Page si ya existe el navegador)

• SeleniumLibrary: ejecuta Open Browser about:blank chrome

La respuesta incluye fallback_applied: true y el contador fallback_steps. Esto ahorra de 2 a 4 llamadas a herramientas por sesión.

Ejecución por lotes

La herramienta execute_batch ejecuta varias palabras clave en una sola llamada MCP, con tan solo un paso de ida y vuelta en lugar de N. Los pasos pueden hacer referencia a resultados de pasos anteriores mediante las variables ${STEP_N}:

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

Si un paso falla, resume_batch te permite insertar pasos de corrección y reintentar desde el punto del error.

Sugerencias en modo estricto

Cuando una palabra clave de Browser Library falla porque el selector coincide con varios elementos (modo estricto de Playwright), el error de la respuesta incluye un consejo que sugiere usar >> nth=0 (índice basado en cero) o cadenas de selección de >> visible=true, con ejemplos concretos que usan el nombre real de la palabra clave y el número de elementos.

Parámetros restringidos por tipo

Todos los parámetros action/mode/strategy usan tipos Literal, lo que genera restricciones enum en el JSON Schema. Esto elimina los valores inventados (por ejemplo, action="setup" en lugar de action="init"). Todos los valores aceptan entradas sin distinguir mayúsculas de minúsculas.

Coerción automática de parámetros

Errores habituales de los LLMs pequeños se corrigen en el servidor:

• Los arrays serializados en JSON (como "[\"Browser\"]") se convierten en arrays nativos

• Las cadenas separadas por comas (como "Browser,BuiltIn") se dividen en listas

• Las palabras clave obsoletas (como GET) se asignan a equivalentes actuales (GET On Session)

Plantillas de instrucciones

Las instrucciones configurables a nivel de servidor guían a los LLM para sigan el patrón descubrir y luego actuar. Elige una plantilla que se ajuste a cada tamaño de tu LLM, desde minimal (~40 tokens) para Claude Opus, hasta detailed (~600 tokens) para Claude Haiku. Consulta Plantillas de instrucciones arriba.

🧠 Memoria semántica persistente

RobotMCP puede aprender de sesiones anteriores y recordar patrones exitosos, localizadores y correcciones de errores, lo que reduce el método de prueba y error en escenarios de prueba repetidos.

Cómo funciona

La memoria se basa en sqlite-vec (búsqueda vectorial) y model2vec (modelos de 256 dimensiones). Cuando está activada, el servidor:

1. Almacena secuencias de pasos correctos, localizadores que funcionan y mapas de error→corrección después de cada llamada a una herramienta

2. Recuerda las prácticas relevantes y las inyecta como sugerencias en las respuestas de las herramientas (por ejemplo, los fallos de execute_step incluyen correcciones anteriores, get_session_state incluye patrones de pasos con éxito previo)

3. Aprende de varios sesiones: la base de datos caliente da igual, se mantiene entre reinicios del servidor

Instalación

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

Configuración

Se activa mediante variables de entorno:

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

Herramientas MCP de memoria

Cuando la memoria está activada, hay cinco herramientas adicionales disponibles:

Mejora de respuestas

Las pistas de memoria se inyectan automáticamente en las respuestas existentes; no es necesaria la colaboración del LLM:

• Fallos de execute_step: En la respuesta de error se incluyen las correcciones anteriores y los localizadores que funcionan.

• get_session: se incluyen los patrones de pasos exitosos previos para el escenario.

• analyze_scenario: se sugieren secuencias de ejecución recordadas de sesiones per vehicle.

Todas las búsquedas de memoria tienen un tiempo de espera de 50 ms para no afectar a la latencia de las respuestas.

Resultados de evaluación comparativa

Se ha probado en 6 escenarios (72 invocations de opencode, 3 iteraciones cada uno) con qwen/qwen3-coder:

Los beneficios de la memoria son más fuertes en escenarios complejos y de varios pasos, donde los localizadores anteriores y las secuencias de pasos reducen las llamadas exploratorias a herramientas.

⚙️ Configuración

rf-mcp funciona con valores predeterminados razonables; cuando necesitas ajustarlo, todo está a una variable de entorno de distancia — plantillas de instrucción, el puente de conexión, la economía de salida/tokens, la memoria, el panel del frontend, la seguridad de escritorio de PlatynUI, y más.

Referencia completa: docs/CONFIGURATION.md — cada variable ROBOTMCP_* con sus valores aceptados y su valor por defecto, además de las banderas y los subcomandos de la CLI de robotmcp.

🤝 Contribuciones

¡Las contribuciones son bienvenidas! Así es como puedes empezar:

1. Haz un fork del repositorio

2. Clona tu fork localmente

3. Instala las dependencias de desarrollo: uv sync

4. Crea una rama de funcionalidad

5. Añade pruebas exhaustivas para la nueva funcionalidad

6. Ejecuta las pruebas: uv run pytest tests/

7. Envía una pull request

📝 Registro de cambios

• v0.34.0 – Automatización de escritorio nativa (rf-mcp[desktop], PlatynUI, listo para Windows); instalador que tiene en cuenta el proyecto y usa las librerías de tu propio proyecto; instrucciones de agente más ligeras; correcciones de cuelgues en el arranque en frío, de bloqueos en el dry-run de Windows y de rutas de suites generadas; perfiles de herramienta restaurados en FastMCP 3

• v0.31.1 – Limpieza del empaquetado (excluye tests/examples del sdist)

• v0.31.0 – Generación BDD y basada en datos, correcciones de la arquitectura de espacios de nombres, memoria persistente, reducción de tokens del 71-88%

• v0.30.1 – Capa de compatibilidad con FastMCP 3.x

• v0.30.0 – Optimización de LLM de pequeño tamaño (perfiles de herramienta, acción de intención, optimización de respuestas, restricciones de tipos)

• v0.29.0 – Plantillas de instrucción, sesiones de pruebas múltiples, ejecución por lotes, tiempos de espera inteligentes

📄 Licencia

Licencia Apache 2.0: consulta el archivo LICENSE para más detalles.

⭐ ¡Danos una estrella en GitHub si RobotMCP te ayuda en tu camino de automatización de pruebas!

Hecho con ❤️ para la comunidad de Robot Framework y automatización con IA.