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

Inglés sencillo entra, pruebas reales de Robot Framework salen — y quien teclea es un agente de IA.

RobotMCP (rf-mcp) es un servidor Model Context Protocol (MCP) que entrega a tu agente de código las llaves de Robot Framework. El agente descubre keywords, ejecuta pasos en vivo con Browser, Selenium, Appium, Requests, una base de datos o el escritorio, ve lo que realmente ocurre y, una vez que los pasos pasan, te escribe una suite .robot limpia. Sin localizadores adivinados, sin keywords alucinadas, sin «en mi máquina funciona». 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.

📺 Tutorial en vídeo

Intro

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

# 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 pruebas se instalan contigo: consulta la tabla de extras en la sección Instalación.

2️⃣ Conéctalo a tu agente de código

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? Cada agente acepta:

{ "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 en el momento de la instalación. Sin él, el primer lanzamiento del servidor tras instalar/actualizar paga varios segundos de compilación de .pyc antes de que se complete el handshake de MCP (algunos clientes agotan el tiempo de espera y muestran el servidor como no disponible). Es un coste único que se paga al 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 por el descubrimiento de keywords, la ejecución en vivo y la generación de suites: tú solo describes la prueba.

Related MCP server: RobotMCP

📚 Documentación

🛠️ Instalación

El Inicio rápido cubre la vía recomendada (uv tool install). Esta sección incluye la tabla de extras, los métodos alternativos de instalación y los detalles completos del registro en el agente.

Extras

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

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 Integración continua, además de una imagen VNC para depuración visual):

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

El paquete 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).

Registro en agentes de código

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 compatibles (cada uno se registra en su propio archivo/formato y se conservan los demás servidores MCP): Claude Code, OpenAI Codex, GitHub Copilot, opencode, Gemini CLI, Kilo Code, goose, Cursor (además de pi, que aparece como planificado hasta que su convención de configuración esté confirmada).

Usa el entorno de tu proyecto. Si instalas en un proyecto que tiene su propio entorno (uv, poetry, pdm, pipenv, rye, hatch o un .venv normal), rf-mcp se configura para ejecutarse contra ese entorno, de modo que verá las librerías, keywords y recursos de tu proyecto, no solo los que se incluyen con él. Lanza el comando resuelto y verifica que tus librerías son alcanzables antes de escribir la configuración; un comando ciego o roto se rechaza. Una instalación global con uvx / uv tool sigue sirviendo para todo proyecto sin preparación por proyecto. Dirige la instalación con -C <dir>, opta por instalar rf-mcp dentro del entorno del proyecto con --into-project, y ejecuta robotmcp doctor --project-dir <dir> para ver a cuáles de tus librerías llega el lanzamiento.

Alcance. Las instalaciones usan --scope project por defecto (escribe en el proyecto actual, por ejemplo ./.mcp.json) cuando el agente lo admite; usa --scope user para una instalación global (en el directorio de inicio). goose solo admite el ámbito de usuario; GitHub Copilot solo admite el ámbito de proyecto.

Seguro y reversible. Todo cambio queda registrado en un manuscrito de instalación con seguimiento de hash (~/.local/state/robotmcp/install-manifest.json). robotmcp uninstall elimina solo las entradas que no hayan cambiado desde la instalación; una entrada editada a mano se deja en su sitio y se informa del cambio, y los servidores no relacionados nunca se tocan. ¿Prefieres editar tú la configuración? Añade { "mcpServers": { "robotmcp": { "command": "robotmcp" } } }.

########

🔌 Plugins de librerías

Amplia RobotMCP con librerías personalizadas mediante el sistema de plugins. Hay dos modos de descubrimiento:

• Puntos de entrada (robotmcp.library_plugins) para librerías empaquetadas.

• Archivos de manifiesto (JSON) dentro de .robotmcp/plugins/ para anular la configuración a nivel de workspace.

Consulta la Guía de autoría de plugins de librerías para instrucciones detalladas y explora el plugin de ejemplo en examples/plugins/sample_plugin para empezar.

🖥️ Panel de control del frontend

RobotMCP incluye un panel de control opcional basado en Django que refleja activos, las keywords y la actividad de las herramientas.

1. Instala los extras del frontend

   pip install rf-mcp[frontend]

2. Inicia el servidor MCP con el panel habilitado

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

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

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

   • Equivalentes 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 y el panel emitirá eventos en streaming automáticamente en cuanto la sesión esté activa.

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

📋 Plantillas de instrucciones

RobotMCP envía instrucciones a nivel de servidor a los LLM mediante la respuesta initialize de MCP, guiándolos para que descubran las keywords antes de ejecutarlas. Esto reduce significativamente las llamadas de herramientas fallidas y el gasto de tokens, especialmente en los LLM más pequeños.

Configuración

Tres variables de entorno controlan el comportamiento de las instrucciones:

Salidas y registros. El canal MCP stdio (stdout) solo transporta JSON-RPC; todos los registros y un banner de estado de una línea van a stderr. El registro por defecto es WARNING para no saturar al cliente; establece ROBOTMCP_LOG_LEVEL=INFO/DEBUG para hacer diagnóstico. La generación de registros nunca bloquea la ejecución (se drena en un hilo en segundo plano con abierto), y el fd 1 nunca se redirige bajo el 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

Establece ROBOTMCP_INSTRUCTIONS=custom y proporciona un archivo a través de ROBOTMCP_INSTRUCTIONS_FILE. Los archivos personalizados admiten la sustitución del marcador {available_tools}. Extensiones permitidas: .txt, .md, .instruction, .instructions. Si el archivo falta o no supera la validación, el servidor recurre automáticamente a la plantilla standard.

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

🪝 Puente de Conexión de Depuración

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

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

Configuración del servidor MCP

Ejemplo de configuración con variables de entorno pasadas para el puente de depuración.

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

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

Preparación de Robot Framework

Importa la librería e inicia el bucle del servidor dentro de la suite que estás depurando:

*** 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 keyword para procesar exactamente una solicitud en cola.

• MCP Stop — indica al bucle del servidor que salga (se usa desde la suite o de forma remota mediante attach_stop_bridge de RobotMCP).

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

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

El puente se vincula a 127.0.0.1 por defecto y espera que los clientes envíen el token compartido en la cabecera X-MCP-Token.

Configurar RobotMCP para conectarse

Inicia robotmcp.server con enrutamiento de conexión proporcionando los datos de conexión del puente mediante variables de entorno (el token debe coincidir con 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 se define ROBOTMCP_ATTACH_HOST, execute_step(..., use_context=true) y otras herramientas que tienen en cuenta el contexto intentan primero ejecutarse dentro de la sesión de depuración activa. Usa las nuevas herramientas MCP para gestionar el puente desde cualquier agente:

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

• attach_stop_bridge — envía un comando /stop, que a su vez ejecuta MCP Stop en la suite depurada.

🎪 Flujos de trabajo de ejemplo

🌐 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: Suite de pruebas de Robot Framework de estilo BDD con keywords Given/When/Then, argumentos incrustados y variables extraídas.

🌐 Pruebas de aplicaciones web (basadas en 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: Suite de pruebas de Robot Framework basada en 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: Suite de pruebas de API que usa RequestsLibrary con un manejo de errores adecuado.

🧪 Pruebas de 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 la suite, guía de localizadores, validación visual y memoria persistente opcional.

Referencia completa: docs/MCP_TOOLS.md — cada herramienta con sus parámetros, valores devueltos y cómo usarla. Tu agente lee esas descripciones directamente; rara vez necesitas invocarlas manualmente.

🧪 Generación de pruebas BDD y basadas en datos

Estito BDD (Given/When/Than)

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 de estilo BDD con keywords 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 paso a paso, usa bdd_group y bdd_intent en execute_step para controlar cómo se agrupan los pasos en keywords de comportamiento. Llama a build_test_suite(bdd_style=True) al final.

Plantillas basadas en 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 usando Test Template con filas de datos nombradas:

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

Ejecuta manage_session(action="start_test", template="Verify Login") para fijar la keyword de plantilla y luego manage_session(action="add_data_row", test_name="Valid User", args=["standard_user", "secret_sauce", "Products"]) para añadir cada fila.

🧠 Optimización de LLMs pequeños

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

Perfiles de herramientas dinámicos

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

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

Perfiles: browser_exec, api_exec, discovery, minimal_exec, full. Reduce el tamaño de las descripciones de herramienta de ~7,000 a ~1,000 tokens. También se puede definir la variable de entorno ROBOTMCP_TOOL_PROFILE.

Verbosidad de las respuestas

Controla el nivel de detalle de las respuestas para reducir el consumo de tokens. Disponible en la mayoría de las herramientas mediante el parámetro detail_level:

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

• standard – salida equilibrada (predeterminada)

• full – salida completa y detallada

Define un valor predeterminado mediante ROBOTMCP_OUTPUT_VERBOSITY=compact|standard|verbose.

Respuestas delta

get_session_state admite respuestas incrementales que solo devuelven las secciones que cambiaron 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 cuando existe una versión anterior. Esto reduce el consumo de tokens en un 50–80 % en flujos de varios pasos donde solo cambian las variables o el contenido de la página entre hoo un paso y uno siguiente.

Externalización de artefactos

Las salidas grandes (código fuente completo de páginas HTML, registros de ejecución, trazas de pila) se externalizan automáticamente en artefactos consultables en lugar de incluirse directamente 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 compactas y conserva el acceso a la salida completa cuando se pide.

Acciones intencionadas

La herramienta intent_action proporciona un punto de interés de prueba común. En lugar de exigir que el LLM conozca nombres de keywords y sintaxis de localizadores específicos de la librería, expresa el propósito:

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

Fallback de navegación

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

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

• SeleniumLibrary: ejecuta Open Browser about:blank chrome.

La respuesta incluye fallback_applied: true y cuenta fallback_steps. Ahorra 2–4 llamadas de herramienta por sesión.

Ejecución en lote

La herramienta execute_batch ejecuta varias keywords en una sola llamada MCP, reduce los viajes de ida y vuelta a 1. Las instrucciones pueden consultar resultados de pasos previos 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 una instrucción no sale bien, resume_batch te permite insertar pasos de corrección y continuar desde el punto del fallo.

Sugerencias en modo estricto

Cuando una keyword de la librería Browser falla porque el selector coincide con varios elementos (modo estricto de Playwright), la respuesta de error incluye una sugerencia con >> nth=0 (índice que comienza en 0) o >> visible=true y ejemplos concretos usando el nombre real de la keyword y el número de elementos.

Parámetros con tipos restringidos

Todos los parámetros de acción, modo y estrategia usan tipos Literal, lo que produce restricciones enum en el JSON Schema. Eso evita valores inventados (por ejemplo, action="setup" quer traduce un action="init"). Todos los valores aceptan entrada sin distinguir mayúsculas.

Coerción automática de parámetros

Los errores frecuentes de LLMs pequeños se corrigen en el lado del servidor:

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

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

• Las keywords obsoletas (GET) se asignan a su equivalente actual (GET On Session).

Instrucciones

Se pueden configurar instrucciones a nivel del servidor para guiar a los LLMs a adoptar el patrón "descubrir, luego actuar". Elige una plantilla en proporción a la capacidad de tu LLM: desde minimal (aproximadamente 40 tokens) para Claude Opus hasta detailed (aproximadamente 600 tokens) para Claude Haiku. Consulta la sección Plantillas de instrucciones más arriba.

🧠 Memoria Semántica Persistente

RobotMCP puede aprenderse de sesiones pasadas y recuperar patrones útiles, localizadores y correcciones de errores, lo que reduce la prueba con prueba al repetir escenarios.

¿Cómo funciona?

La memoria se basa en sqlite-vec (búsqueda vectorial) y model2vec (vectors dimensionalidad 256). Cuando está activa, el servidor:

1. Guarda secuencias de pasos exitosas, localizadores que funcionan y mapeos error → corrección después de cada llamada.

2. Recupera recuerdos relevantes y los envía como pistas dentro de las respuestas (por ejemplo, si execute_step falla, incluye correcciones previas; get_session_state include patrones de pasos válidos anteriores).

3. Aprende entre sesiones: la base de datos persistida se conserva entre reinicios del servidor.

Instalación

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

Configuración

Ejecuta la instalación 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á habilitada, están disponibles cinco herramientas adicionales:

Exclusión en respuestas

Las sugerencias de memoria se inyectan automáticamente en las respuestas de las herramientas existentes, sin necesidad de la cooperación del LLM:

• Fallos de execute_step: se incluyen correcciones anteriores y fallos que funcionaron en la respuesta.

• En get_session_state: se incluyen patrones de pasos de sesiones anteriores para el escenario .

• En analyze_scenario: se sugieren secuencias de pasos de sesiones pasadas.

Todas las consultas a memoria tienen un umbral de 50 ms para no afectar al sufrimiento de la respuesta.

Resultados del benchmark

Probado en 8 escenarios (72 llamadas de opencode, 3 iteraciones cada uno) con qwen/qwen3-coder:

Los beneficios de la memoria son más marcados en los escenarios complejos y multi-paso, 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 necesites ajustarlo, todo queda a una variable de entorno: plantillas de instrucciones, el puente de adjuntos, economía de salida/tokens, memoria, el panel frontal, la seguridad de PlatynUI para escritorio y más.

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

🤝 Contribuciones

¡Damos la bienvenida a las contribuciones! Así es cómo 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 características

5. Añade pruebas exhaustivas para la nueva funcionalidad

6. Ejecuta los tests: uv run pytest tests/

7. Envía un pull request

📝 Registro de cambios

• v0.34.0 – Automatización nativa de escritorio (rf-mcp[desktop], PlatynUI, preparado para Windows); instalador que reconoce tu proyecto y usa sus propias librerías; instrucciones de agente más sencillas; correcciones del cuelge de arranque en frío, del bloqueo de nodo seco en Windows y de las rutas generadas; perfiles de herramientas restaurados en FastMCP 3

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

• v0.31.0 – Generación BDD/data-driven, correcciones de arquitectura de namespaces, memoria persistente, reducción de tokens del 71–88%

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

• v0.30.0 – Optimización para LLMs pequeñas (perfiles de herramientas, acción de intento, optimización de respuesta, restricciones de tipo)

• v0.29.0 – Plantillas de instrucciones, sesiones de múltiples pruebas, ejecución por lotes, timeouts inteligentes

📄 Licencia

Apache 2.0 Licencia - consulta el archivo LICENSE para obtener más información.

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

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