4,500+ servers built on MCP Fusion
Vinkius

TestMu AI MCP. Audit cross-browser builds & debug sessions from chat.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

TestMu AI (formerly LambdaTest) MCP on Cursor AI Code Editor MCP Client TestMu AI (formerly LambdaTest) MCP on Claude Desktop App MCP Integration TestMu AI (formerly LambdaTest) MCP on OpenAI Agents SDK MCP Compatible TestMu AI (formerly LambdaTest) MCP on Visual Studio Code MCP Extension Client TestMu AI (formerly LambdaTest) MCP on GitHub Copilot AI Agent MCP Integration TestMu AI (formerly LambdaTest) MCP on Google Gemini AI MCP Integration TestMu AI (formerly LambdaTest) MCP on Lovable AI Development MCP Client TestMu AI (formerly LambdaTest) MCP on Mistral AI Agents MCP Compatible TestMu AI (formerly LambdaTest) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

TestMu AI MCP Server lets your agent audit cross-browser test builds and inspect failure context directly from your IDE. Use it to list build status, extract console errors via `get_session`, fetch bug screenshots, or pull full video recordings of failed automated runs.

What your AI agents can do

Get build

Fetches specific telemetry data for one defined LambdaTest build run.

Get build sessions

Extracts a complete list of individual test sessions linked to a particular Build ID.

Get screenshots

Retrieves visual bug screenshots that were captured during the execution of a test session.

+ 7 more capabilities included
List all test automation builds

Retrieves grouped telemetry data for multiple browser testing frameworks (Selenium, Playwright, Cypress) from parent CI/CD build IDs.

Extract session failure context

Gathers deep debugging information for a specific test run, including console errors and network traffic logs.

Retrieve visual artifacts

Fetches both the URL for a bug screenshot and the full video recording of any completed browser execution.

Get command-level logs

Pulls raw, time-stamped Selenium or Appium commands that executed during a specific test session.

Audit supported platforms and tunnels

Queries the grid for currently available OS/browser combinations (macOS, Windows, iOS, Android) and lists active secure local tunnels.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

TestMu AI (formerly LambdaTest) MCP Server: 10 Tools for Testing Ops

Access all diagnostic tools here. Run builds, inspect sessions, retrieve artifacts, and audit platform capabilities—all controlled by your agent.

get019d75c3

get build

Fetches specific telemetry data for one defined LambdaTest build run.

get019d75c3

get build sessions

Extracts a complete list of individual test sessions linked to a particular Build ID.

get019d75c3

get screenshots

Retrieves visual bug screenshots that were captured during the execution of a test session.

get019d75c3

get session

Gathers deep context for one specific automated test run, including console errors and network data.

get019d75c3

get session logs

Pulls precise command logs (Selenium/Appium) that executed during a defined test session.

get019d75c3

get video

Retrieves the full video recording URL for an entire test execution.

list019d75c3

list builds

Lists all completed or running test automation builds on LambdaTest Cloud.

list019d75c3

list platforms

Returns a list of every combination of macOS, Windows, iOS, and Android versions available in the testing grid.

list019d75c3

list sessions

Provides basic status details (OS, browser, duration) for recent automated test sessions.

list019d75c3

list tunnels

Lists all active secure Tunnels that are currently connected and running for local testing purposes.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with TestMu AI (formerly LambdaTest), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Listen up. TestMu AI MCP Server lets your agent audit cross-browser test builds and dig into failure context right from your IDE. It's built to handle all that messy, complex debugging work so you don't have to manually jump between ten tabs.

When you need to know what happened with a build, you can list all completed or running test automation builds using list_builds. This function retrieves grouped telemetry data for multiple major browser testing frameworks—whether it’s Selenium, Playwright, or Cypress—all tied back to your primary CI/CD build IDs. If you're checking specific details on one run, you can fetch precise telemetry data for a single LambdaTest build run using get_build.

To narrow down the scope, your agent can extract a complete list of individual test sessions associated with a parent Build ID via get_build_sessions. For basic status checks on recent runs, you'll get fundamental details like OS, browser, and duration for automated test sessions by calling list_sessions. If you want to audit your local setup before running tests, the server lists all active secure Tunnels connected for development purposes with list_tunnels, and it can also return a list of every combination of macOS, Windows, iOS, and Android versions available in the testing grid using list_platforms.

When you pinpoint the exact failing test run, you'll gather deep debugging information for that specific automated test session by invoking get_session. This function doesn't just give you a status code; it provides crucial data like console errors and network traffic logs. You can also pull raw command-level execution logs—those precise, time-stamped Selenium or Appium commands—by calling get_session_logs for the defined session.

To figure out what caused the failure, you'll retrieve visual bug screenshots captured during the test session using get_screenshots. Furthermore, if you need to see exactly how something broke, the server retrieves the full video recording URL of an entire failed execution via get_video. To isolate problems in a large deployment, you can fetch telemetry for child sessions under specific parent CI/CD builds, letting you pinpoint exact regression spots.

This whole setup means that instead of just seeing 'Failed,' your agent gives you the full picture: it shows you why it failed. You use these tools to check build status (list_builds), narrow down the session list (get_build_sessions), grab the raw context and errors (get_session and get_session_logs), get proof of the failure (screenshots via get_screenshots, videos via get_video), or just verify if your target platform even exists (list_platforms).

It’s everything you need to debug, nothing you don't.

How TestMu AI MCP Works

  1. 1 Subscribe to this server and provide your TestMu AI Username and Access Key.
  2. 2 Connect the credentials to Claude, Cursor, or any MCP-compatible client.
  3. 3 Start by prompting your agent with a task, like 'List builds for staging,' to retrieve diagnostic data.

The bottom line is you manage your entire testing grid and all its artifacts from conversation, without leaving your current workspace.

Who Is TestMu AI MCP For?

This is for the QA Automation Engineer who hates switching between dashboards; they need to monitor build health and inspect deep diagnostic logs without ever leaving their IDE. It’s also essential for DevOps Teams managing complex CI/CD pipelines, needing quick audits of test results across environments.

QA Automation Engineer

Uses the server to check list_builds status and run get_session when a flaky test fails; they pull logs and screenshots directly for root cause analysis.

Software Developer

Connects the agent to retrieve session videos (get_video) or specific bug screenshots from failed tests, allowing rapid iteration on UI failures right in their coding environment.

DevOps Engineer

Uses list_builds and list_platforms to audit CI/CD test results across different environments; they ensure the correct OS/browser matrix is available before a major deployment push.

What Changes When You Connect

  • Instantly diagnose failures. Instead of switching to a dashboard, you can ask your agent to run get_session on failure ID 'xyz', pulling console errors and network configs in one query.
  • Reproduce UI bugs immediately. You don't just get an error message; using get_screenshots pulls the exact bug picture, while get_video gives you the full playback of the flaky moment.
  • Audit build health across environments. Use list_builds to see if your staging and production regression tests all completed successfully, giving you a high-level overview without drilling into each one.
  • Deep dive into specific test runs. You can use get_session_logs to pull precise command-level logs—it's more detail than just the console output; it shows what commands ran and when.
  • Verify compatibility upfront. Before writing a single line of code, run list_platforms to confirm if your required combination (e.g., Android 13 on Chrome) is actually supported by the grid.
  • Monitor local development connections. Use list_tunnels to check which secure tunnels are active for localhost testing; this tells you if your local dev environment connected properly.

Real-World Use Cases

01

Debugging a sporadic UI failure

A developer reports a button sometimes fails on Safari. Instead of manually clicking through the dashboard, they ask their agent: 'Show me the session for Build X.' The agent runs get_session, pulling console errors and network logs. They also run get_screenshots to get visual proof of the failure right in their chat window.

02

Auditing CI/CD readiness

The DevOps team needs to know if all regions are covered before deployment. They use the agent to call list_builds, checking status for 'EU-Staging' and 'US-Prod'. Then they run list_platforms to verify that Chrome 120+ is available on both Windows and macOS, ensuring full coverage.

03

Debugging a complex API call failure

A QA engineer finds a test fails due to an unknown command error. They use the agent to run get_session_logs for that specific session ID. This pulls raw, time-stamped Selenium commands, allowing them to see exactly which protocol failed and why.

04

Reviewing a critical hotfix test

The team pushed an urgent hotfix. Instead of watching a video on another tab, they ask the agent: 'Show me the full video for Build Y.' The agent runs get_video, providing the link immediately, so the developer can review the entire execution flow in seconds.

The Tradeoffs

Treating all logs as one endpoint

Just dumping all raw build data into a single text file to search for 'NoSuchElement'. This is overwhelming, and you lose the specific context of which session or when the error happened.

Don't just dump everything. First, use list_builds to find the correct Build ID. Then, run get_build_sessions to narrow it down to a specific test run ID. Finally, call get_session on that specific ID; this links the raw logs and errors together.

Missing platform context

Debugging a failure report for 'Windows 10 Chrome' when your build actually ran on 'Windows 11 Edge'. The error looks the same, but the fix is different.

Always check list_platforms first. Confirm that the environment you are debugging against matches what was run, then use that verified platform data to narrow down which specific session ID you need.

Assuming logs contain everything

A test fails, and the agent only gives standard console output. You assume the command failed, but maybe the network connection dropped.

Don't rely just on the console. For deep diagnostics, run get_session to get network configurations, and if needed, use get_session_logs for the raw protocol commands that happened.

When It Fits, When It Doesn't

Use this server if your primary need is granular, artifact-level debugging of automated tests—specifically, when you need screenshots, video links, or command logs tied to a specific build ID. You must use it if you are diagnosing 'flaky' behavior because the simple status check isn't enough.

Don't use this server if all you need is a basic status report (e.g., 'Did the nightly test pass?'). For those quick checks, a standard CI dashboard works fine. You only need this detailed tooling when that simple answer ('yes/no') isn't accurate enough and you gotta know why it failed.

Key decision points: If you can’t pull visual proof or command history via get_screenshots or get_session_logs, then the tool likely won't solve your problem.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by TestMu AI. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

get_build get_build_sessions get_screenshots get_session get_session_logs get_video list_builds list_platforms list_sessions list_tunnels

Debugging flaky tests shouldn't mean clicking through five different tabs.

Right now, when a test fails on Staging, you have to navigate to the TestMu AI dashboard. You find the Build ID; then you click into the session details; sometimes you need to open a separate tab for logs, and another one for the video recording. It's clicking through 4-5 different views just to gather context.

With this MCP server, your agent handles all that legwork. You simply tell it: 'What went wrong with build X?' The agent runs `get_session`, pulling console errors, network configs, *and* the failure screenshot—all presented back to you in one chat response.

TestMu AI MCP Server: Get full diagnostic data instantly.

The biggest time sink is cross-referencing artifacts. You pull the error from `get_session`, then copy the timestamps, then search for a video link using another endpoint. It's manual context stitching—a huge waste of time.

Now, your agent ties it all together. By orchestrating calls like listing builds (`list_builds`) and pulling specific artifacts (`get_video`), you get the full picture without ever leaving your IDE or switching focus. The workflow just works.

Common Questions About TestMu AI MCP

How do I list all my recent test automation build statuses using list_builds? +

You ask your agent to run list_builds. It groups and lists thousands of executed Selenium, Cypress, or Playwright builds for you. You get the high-level telemetry needed to check overall system health.

What is the difference between list_sessions and get_session? +

list_sessions gives a basic summary: OS, browser version, and duration of recent runs. get_session, however, goes deep; it pulls all the actual debugging data—console errors, network configurations, and metadata.

Can I retrieve both the video and the screenshots for one failure? +

Yes. You first need to use get_build_sessions to find the right session ID. Then you ask the agent to run both get_screenshots and get_video on that specific ID, giving you two distinct artifacts.

Which tool should I use to check OS compatibility? +

Use list_platforms. This tool queries the grid and returns a precise list of every combination of macOS, Windows, iOS, and Android versions that are currently supported by the testing environment.

How do I check for active, secure testing environments using list_tunnels? +

Use list_tunnels to view all currently running, secured tunnels (UnderTest). This quickly verifies your local machine connection status. It ensures that the environment you are debugging against is correctly established and operational.

What specific command-level details can I get using get_session_logs? +

get_session_logs extracts precise Selenium or Appium commands used during a test run. This provides the full protocol calls that failed, which is critical for debugging flaky UI interactions and understanding execution context.

How do I list every single test session tied to a large CI/CD run using get_build_sessions? +

Calling get_build_sessions fetches all explicit test sessions linked directly to a specific build ID. This helps you analyze the complete scope of failures across an entire deployment group, rather than just relying on summaries.

How can I get a full list of supported browser and OS combinations using list_platforms? +

list_platforms returns an exact matrix of all available capabilities. It details every combination of macOS, Windows, iOS, and Android versions currently running in the grid for your tests.

Can I see the exact console errors from a failed browser test through my agent? +

Yes. Use the get_session_details tool with a specific Session ID. Your agent will retrieve full metadata including console logs, network configurations, and execution artifacts, helping you identify the root cause of the failure instantly.

How do I retrieve the video recording of a specific test execution? +

Ask your agent to get_session_video for a targeted Session ID. Your agent will return the absolute MP4 URL to stream or download the complete browser session recording, which is essential for debugging flakey UI bugs.

Can my agent check if our secure localhost tunnel is active? +

Absolutely. Use the list_active_tunnels tool to identify dedicated private connection endpoints. Your agent will report which TestMu AI tunnels are currently running, ensuring you can test local environments from the cloud.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 10 tools

We've already built the connector for TestMu AI. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.