robot-ai-mcp
Provides tools for Robot Framework test automation, including discovering tests and resources, creating test drafts from requirements, dry-running and executing suites, and parsing Robot Framework output.xml results.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@robot-ai-mcp list all test cases in the login suite"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Robot AI Tools
An MCP server for agentic development with Robot Framework.
What's Included
robot-ai-mcp: local MCP server exposing Robot Framework operations.
The MCP server provides these tools:
robot_list_tests: discover test cases, tags, source files, and line numbers without executing them.robot_list_resources: discover.resourcefiles, keywords, arguments, and imports without executing them.robot_create_test: create a reviewable draft from a natural-language requirement using project.resourcefiles, libraries, and matched keywords.robot_dry_run: validate imports, variables, and keyword resolution without running test keywords.robot_run: execute selected suites with optional include/exclude tags and return compact results and failure details.robot_parse_results: summarize a Robotoutput.xmlfile.
All paths are resolved relative to the workspace and must remain inside it. Execution uses argument-list subprocesses, bounded responses, and a timeout.
Related MCP server: RobotMCP
Trust Boundary
The MCP server is intended for a trusted local workspace. It does not sandbox Robot Framework, Python libraries, variable files, subprocesses, network access, or environment variables. A Robot suite can therefore read files, access the network, start processes, and execute Python code with the same OS permissions as the MCP server.
Only point the server at repositories and test dependencies that you trust. Do not expose this local server to untrusted clients or use it as a security boundary. The server rejects paths outside the workspace, but that check does not replace operating-system isolation.
By default, execution removes obvious credential-like environment variables
such as tokens, passwords, secrets, and API keys. If a trusted test requires
one of them, list its name in ROBOT_AI_ENV_ALLOWLIST as a comma-separated
environment variable. Test output and Robot-generated HTML artifacts can still
contain sensitive data and must be handled accordingly.
Requirements
Python 3.10 or newer
Robot Framework 6.1 or newer
Setup
Install the locked dependencies and run the test suite:
uv sync --locked --all-groups
uv run --locked --no-sync pytest
uv run --locked --no-sync ruff check src tests
uv run --locked --no-sync mypy srcRun the MCP server directly when needed:
uv run --locked --no-sync robot-ai-mcpThe repository does not include client-specific agent configuration. Configure the MCP server in the client of your choice using the local STDIO transport.
OpenCode
Add the following entry to your OpenCode configuration, such as the project
opencode.json or your user configuration:
{
"mcp": {
"robot-framework": {
"type": "local",
"command": [
"uv",
"--directory",
"/absolute/path/to/robot-ai-tools",
"run",
"--locked",
"--no-sync",
"robot-ai-mcp"
],
"enabled": true,
"timeout": 360000
}
}
}Replace /absolute/path/to/robot-ai-tools with the repository path. Restart
the client after changing its MCP configuration.
Kilo Code
Kilo Code supports this MCP through the local STDIO transport. Create a
project-level kilo.jsonc in the repository root, or use .kilo/kilo.jsonc:
{
"mcp": {
"robot-framework": {
"type": "local",
"command": [
"uv",
"--directory",
"/absolute/path/to/robot-ai-tools",
"run",
"--locked",
"--no-sync",
"robot-ai-mcp"
],
"enabled": true,
"timeout": 360000
}
}
}Replace /absolute/path/to/robot-ai-tools with the path to this repository.
The timeout value is in milliseconds. Kilo Code will then discover
robot_list_tests, robot_list_resources, robot_create_test, robot_run,
robot_dry_run, and robot_parse_results. Approve the tools in Kilo Code when
prompted, or add them to its MCP permissions according to your local policy.
The server is intended for trusted workspaces and is not sandboxed. See Trust Boundary before enabling it for a project.
Other MCP Clients
For another MCP-compatible agent, add a local/STDIO server using the same
command and arguments shown above. Clients that use separate command and
args fields should configure them as follows:
command: uv
args: --directory /absolute/path/to/robot-ai-tools run --locked --no-sync robot-ai-mcpUse the client's equivalent of enabled, configure a timeout of at least five
minutes for long-running Robot suites, and pass workspace explicitly when the
client does not start the server from the repository directory.
Typical Workflow
Use the tools in this order when adding or changing a test:
Discover the relevant suite with
robot_list_testsand existing keywords withrobot_list_resources.Create a draft with
robot_create_testwhen starting from a requirement.Replace the draft's intentional
Failplaceholder with real keywords and assertions.Run
robot_dry_runafter changing imports, variables, or keyword names.Run the smallest relevant scope with
robot_run.Use
robot_parse_resultsto inspect the generatedoutput.xml.
Each execution gets a fresh result directory when output_dir is omitted.
When an explicit directory is supplied, the server removes only the previous
Robot result artifacts before starting, so an old output.xml cannot be
reported as the current execution.
Drafts are tagged ai-generated and draft, document the requirement,
import project .resource files and libraries, and scaffold initial test steps
from matching keywords with argument placeholders. Existing files are protected
unless overwrite=true is explicitly supplied.
Example tool calls:
robot_list_tests(workspace=".", path="tests")
robot_list_resources(workspace=".", path="tests")
robot_create_test(
workspace=".",
request="A valid user can sign in. Show the account page.",
target_path="tests/sign_in.robot",
tags=["auth"]
)
robot_dry_run(workspace=".", paths=["tests/sign_in.robot"])
robot_run(workspace=".", paths=["tests/sign_in.robot"], include_tags=["smoke"])
robot_parse_results(
workspace=".",
output_xml=".robot-ai/results/<run>/output.xml"
)Project Layout
src/robot_ai_tools/ Runner and MCP server implementation
tests/ Python tests and Robot fixturesExtending
Keep tool behavior in src/robot_ai_tools/runner.py and expose thin MCP
wrappers in mcp_server.py. New tools should return structured JSON, enforce
workspace containment, use argument-list subprocesses, and provide bounded or
persisted output. Add agent guidance only for repeatable workflows.
Available Tools
6 toolsrobot_create_testC
Create a reviewable Robot draft using nearby resources, libraries, and reusable keywords.
Inputs: request (required), target_path (required), tags, overwrite, +2 more. Returns: object
robot_dry_runA
Validate Robot imports, variables, and keywords without test execution.
Robot libraries and variable files may still execute code while importing.
Inputs: paths (required), timeout, workspace. Returns: object
robot_list_resourcesA
List Robot resource files, keywords, and imports without executing them.
Inputs: path, workspace. Returns: object
robot_list_testsB
List Robot test cases, tags, source files, and line numbers without executing them.
Inputs: path, workspace. Returns: object
robot_parse_resultsA
Parse output.xml and return compact test statistics and failure messages.
Inputs: workspace (required), output_xml (required). Returns: object
robot_runB
Run selected Robot suites and return JSON with status, failures, and output location.
Inputs: paths (required), timeout, workspace, output_dir, +2 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool targets a distinct phase of the Robot Framework workflow: static discovery, draft creation, validation, execution, and result analysis. There is no meaningful overlap between listing tests, listing resources, dry-running, running, or parsing results.
Tools consistently use the robot_ prefix and snake_case, with a clear verb_noun pattern for most names (parse_results, list_tests, list_resources, create_test). robot_run and robot_dry_run deviate slightly by omitting an object noun, but the pattern remains predictable and readable.
Six tools is well-scoped for a Robot Framework assistant, covering the essential actions without redundancy. Each tool earns its place in the workflow.
The surface covers the core lifecycle: discover tests/resources, create tests, validate, execute, and parse results. Minor gaps exist such as no tool for updating/deleting tests or detailed log inspection, but these are workarounds rather than dead ends.
Maintenance
Related MCP Connectors
Direct access to Cypress tests results and accessibility reports in your AI workflow.
Approved test intent, reviewed Playwright automation and run evidence, inside your editor.
Create, run and debug Leapwork Play tests and runlists, build knowledge bases, and use AI workflows.
Roast any AI agent idea from your IDE: verdict tier, readiness score, top risk, shareable URL.
Related MCP Servers
FlicenseAqualityFmaintenanceEnables AI agents to run and create Squish test scripts and test suites and analyze the results.1913-- AlicenseBqualityBmaintenanceRobotMCP is a comprehensive Model Context Protocol (MCP) server that bridges the gap between human language and Robot Framework automation. It enables AI agents to understand test intentions, execute steps interactively, and generate complete test suites from successful executions.194,181 PyPI118Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables generating Robot Framework test cases with SeleniumLibrary, creating page object models, and performing performance monitoring through natural language.MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to drive Robot Framework through natural language, discovering keywords, running live test steps across web, mobile, API, database, and desktop targets, and generating clean .robot test suites from plain-English instructions.Apache 2.0