How do I use katalon-mcp-server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@katalon-mcp-server Analyze my Katalon project structure" 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.

katalon-mcp-server

by PareshSoni468

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

Katalon MCP Server

License: MIT Node.js Version TypeScript

A comprehensive Model Context Protocol (MCP) server that bridges Katalon Studio with Claude AI for intelligent QA automation. This project enables seamless integration between your existing Katalon Studio and Katalon Runtime Engine licenses with AI-powered test automation capabilities.

📋 Table of Contents

Related MCP server: QA Studio MCP Server

🚀 Quick Start

# Clone the repository
git clone https://github.com/your-organization/katalon-mcp-server.git
cd katalon-mcp-server

# Install dependencies
npm install

# Build the project
npm run build

# Start the server
npm start

📋 Prerequisites

Before setting up the Katalon MCP Server, ensure you have the following installed:

Required Software

Node.js: Version 18.0.0 or higher (Download)
npm: Comes with Node.js (verify with npm --version)
Katalon Studio or Katalon Runtime Engine: Valid license required
Claude Desktop: For MCP integration (Download)

System Requirements

Operating System: Windows 10/11, macOS 10.15+, or Linux (Ubuntu 18.04+)
Memory: Minimum 4GB RAM (8GB recommended)
Storage: At least 1GB free space
Network: Internet connection for package installation

Katalon Setup

Valid Katalon Studio or Runtime Engine license
Katalon installation path accessible to the system
Environment variable KATALON_HOME (optional, auto-detected if not set)

📦 Installation

Method 1: Clone from GitHub (Recommended)

# Clone the repository
git clone https://github.com/your-organization/katalon-mcp-server.git

# Navigate to the project directory
cd katalon-mcp-server

# Install dependencies
npm install

# Build the TypeScript project
npm run build

Method 2: Download ZIP

Download the latest release from GitHub Releases
Extract the ZIP file to your desired location
Open terminal/command prompt in the extracted folder
Run the installation commands:

npm install
npm run build

Method 3: Automated Setup (Windows)

For Windows users, you can use the provided PowerShell script:

# Run the setup script as Administrator
.\setup.ps1

This script will:

Install all dependencies
Build the project
Test the server startup
Display next steps for configuration

⚙️ Configuration

1. Environment Variables (Optional)

Set up environment variables for better integration:

# Windows (Command Prompt)
set KATALON_HOME=C:\Program Files\Katalon_Studio_Engine

# Windows (PowerShell)
$env:KATALON_HOME="C:\Program Files\Katalon_Studio_Engine"

# macOS/Linux
export KATALON_HOME="/Applications/Katalon Studio Engine.app/Contents/MacOS"

2. Claude Desktop Configuration

Add the following configuration to your Claude Desktop settings:

Location of config file:

Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Configuration:

{
  "mcpServers": {
    "katalon-mcp-server": {
      "command": "node",
      "args": ["/absolute/path/to/katalon-mcp-server/dist/index.js"],
      "cwd": "/absolute/path/to/katalon-mcp-server"
    }
  }
}

Example configurations by OS:

Windows:

{
  "mcpServers": {
    "katalon-mcp-server": {
      "command": "node",
      "args": ["D:\\Projects\\katalon-mcp-server\\dist\\index.js"],
      "cwd": "D:\\Projects\\katalon-mcp-server"
    }
  }
}

macOS/Linux:

{
  "mcpServers": {
    "katalon-mcp-server": {
      "command": "node",
      "args": ["/Users/yourname/Projects/katalon-mcp-server/dist/index.js"],
      "cwd": "/Users/yourname/Projects/katalon-mcp-server"
    }
  }
}

3. Verification

Test your setup by running:

# Start the server
npm start

# You should see output similar to:
# Katalon MCP Server started successfully
# Listening on stdio...
# Available tools: 6

🚀 Usage

Starting the Server

# Development mode (rebuilds on changes)
npm run dev

# Production mode
npm start

# Watch mode (rebuilds automatically)
npm run watch

Basic Commands in Claude

Once configured, you can use these commands in Claude Desktop:

# Analyze a Katalon project
Analyze my Katalon project at C:\MyProject\ECommerce_Tests

# Create a new test case
Create a login test case for my application with username field id="email" and password field id="password"

# Execute a test suite
Execute the regression test suite using Chrome browser

# Manage object repository
Update the checkout button object with smart healing enabled

🛠️ Available Tools

The Katalon MCP Server provides the following tools for Claude AI:

1. Project Analysis

Tool: katalon_analyze_project
Purpose: Analyze project structure, health metrics, and provide recommendations
Usage: Provides comprehensive insights into test suite organization and object repository health

2. Test Case Management

Tool: katalon_create_test_case
Purpose: Create new test cases with intelligent templates
Templates: Login, API Testing, Data-Driven, Mobile, Custom
Features: Automatic object repository integration

3. Test Execution

Tool: katalon_execute_test_suite
Purpose: Execute test suites with real-time monitoring
Features: Multi-browser support, execution profiles, detailed reporting

4. Object Repository Management

Tool: katalon_manage_object_repository
Purpose: Advanced object repository operations
Features: Smart healing, object health analysis, bulk operations

5. Keyword Management

Tool: katalon_manage_keywords
Purpose: Create and manage custom keywords
Features: Built-in templates, parameter handling, documentation generation

6. Smart Healing

Tool: katalon_smart_healing
Purpose: Automatic object healing and optimization
Features: Multiple fallback strategies, confidence scoring, auto-updates

🔧 Development

Project Structure

katalon-mcp-server/
├── src/
│   ├── index.ts                 # Main server entry point
│   └── katalon/
│       ├── keyword-manager.ts   # Keyword management tools
│       ├── object-repository.ts # Object repository operations
│       ├── project-manager.ts   # Project analysis and management
│       ├── smart-healing.ts     # Smart healing functionality
│       └── test-executor.ts     # Test execution engine
├── dist/                        # Compiled JavaScript (generated)
├── package.json                 # Project dependencies and scripts
├── tsconfig.json               # TypeScript configuration
├── setup.ps1                  # Windows setup script
├── README.md                   # This file
└── USAGE_EXAMPLES.md          # Comprehensive usage examples

Available Scripts

# Build the project
npm run build

# Start the server
npm start

# Development mode (build + start)
npm run dev

# Watch mode (auto-rebuild)
npm run watch

# Run tests (if available)
npm test

Building from Source

# Clone and setup
git clone https://github.com/your-organization/katalon-mcp-server.git
cd katalon-mcp-server
npm install

# Development workflow
npm run watch  # In one terminal (auto-rebuilds)
npm start      # In another terminal (run server)

✨ Features

🚀 Core Capabilities

Test Suite Execution: Execute existing Katalon test suite collections with real-time monitoring
Smart Test Case Creation: Generate new test cases with intelligent object identification
Object Repository Management: Advanced object repository handling with smart healing
Keyword Management: Comprehensive support for built-in and custom Katalon keywords
Smart Healing: Automatic object healing with multiple fallback strategies
Execution Analytics: Detailed test execution reports and insights

🔧 Key Components

1. Project Manager (`project-manager.ts`)

Analyze Katalon project structure and health
Create new test cases with templates
Provide project insights and recommendations
Support for multiple test case templates (Login, API, Data-Driven, Mobile)

2. Test Executor (`test-executor.ts`)

Execute test suites and test suite collections
Real-time execution monitoring and logging
Comprehensive execution reports with screenshots
Support for multiple browsers and execution profiles
Cross-platform Katalon Runtime Engine detection

3. Object Repository Manager (`object-repository.ts`)

Advanced object repository operations
Smart healing configuration and management
Object health analysis and recommendations
Bulk object operations and optimization

4. Keyword Manager (`keyword-manager.ts`)

Create and manage custom keywords
Built-in keyword templates and best practices
Parameter handling and validation
Documentation generation for custom keywords

5. Smart Healing Engine (`smart-healing.ts`)

Automatic object healing with confidence scoring
Multiple fallback strategies (XPath, CSS, attributes)
Learning from previous healing attempts
Integration with object repository for seamless updates

🤝 Contributing

We welcome contributions! Please follow these steps:

Getting Started

Fork the repository

Clone your fork:

git clone https://github.com/your-username/katalon-mcp-server.git

Create a feature branch:

git checkout -b feature/your-feature-name

Development Guidelines

Follow TypeScript best practices
Add appropriate error handling
Include JSDoc comments for public methods
Test your changes thoroughly
Update documentation as needed

Submitting Changes

Commit your changes:

git add .
git commit -m "feat: add new feature description"

Push to your fork:

git push origin feature/your-feature-name

Create a Pull Request on GitHub

Commit Message Convention

We use conventional commits:

feat: for new features
fix: for bug fixes
docs: for documentation changes
refactor: for code refactoring
test: for adding tests

🐛 Troubleshooting

Common Issues

1. Katalon Runtime Engine Not Found

Error: Could not locate Katalon Runtime Engine

Solution:

Ensure Katalon is installed and accessible
Set KATALON_HOME environment variable
Verify Katalon license is valid

2. Node.js Version Issues

Error: Node.js version 18.0.0 or higher is required

Solution:

Update Node.js to version 18+ from nodejs.org
Use Node Version Manager (nvm) to manage versions

3. Permission Errors (Windows)

Error: EACCES permission denied

Solution:

Run terminal as Administrator
Check folder permissions
Ensure antivirus isn't blocking the application

4. TypeScript Compilation Errors

Error: Cannot find module or type declarations

Solution:

Delete node_modules and package-lock.json
Run npm install again
Ensure TypeScript version compatibility

5. Claude Desktop Not Connecting

MCP server not appearing in Claude Desktop

Solution:

Verify config file location and syntax
Use absolute paths in configuration
Restart Claude Desktop after configuration changes
Check server logs for errors

Getting Help

Issues: Report bugs on GitHub Issues
Discussions: Ask questions in GitHub Discussions
Documentation: Check USAGE_EXAMPLES.md for detailed examples

Debug Mode

Enable debug logging:

# Set debug environment variable
DEBUG=katalon-mcp-server npm start

# Or on Windows PowerShell
$env:DEBUG="katalon-mcp-server"; npm start

📚 Documentation

Usage Examples: Comprehensive examples and use cases
API Documentation: Detailed API reference (coming soon)
Best Practices: Recommended practices for optimal usage (coming soon)

🏗️ Architecture

The Katalon MCP Server follows a modular architecture:

┌─────────────────┐
│   Claude AI     │
└─────────┬───────┘
          │ MCP Protocol
┌─────────▼───────┐
│  MCP Server     │
│  (index.ts)     │
└─────────┬───────┘
          │
    ┌─────▼─────┐
    │  Katalon  │
    │  Modules  │
    └─────┬─────┘
          │
┌─────────▼───────┐
│ Katalon Studio/ │
│ Runtime Engine  │
└─────────────────┘

🔒 Security Considerations

Local Execution: All operations execute locally on your machine
No Data Transmission: Test data and project information stay on your system
License Respect: Requires valid Katalon license for all operations
File System Access: Limited to specified project directories

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Anthropic for the Model Context Protocol specification
Katalon for the comprehensive test automation platform
TypeScript community for excellent tooling
Open Source Contributors who make projects like this possible

Made with ❤️ for the QA Automation Community

For more examples and advanced usage patterns, see USAGE_EXAMPLES.md.

Create, update, and delete test objects
Smart healing capabilities for dynamic elements
Object health analysis and recommendations
Best practices guidance for object identification
Duplicate selector detection and resolution

4. Keyword Manager (`keyword-manager.ts`)

Browse 150+ built-in Katalon keywords with examples
Create and manage custom keywords
Keyword usage analytics and recommendations
Code generation assistance for common patterns

5. Smart Healing System (`smart-healing.ts`)

Automatic object healing with 6 different strategies
Configurable healing confidence thresholds
Healing attempt history and analytics
Visual recognition capabilities (extensible)
Comprehensive healing reports and recommendations

Installation

Prerequisites

Node.js 18+
Katalon Studio or Katalon Runtime Engine
TypeScript 5+

Setup

Clone this repository
Install dependencies:
```
npm install
```
Build the project:
```
npm run build
```
Start the MCP server:
```
npm start
```

Configuration

Katalon Integration

The server automatically detects Katalon installations in common locations:

Windows: C:\\Katalon_Studio_Engine\\katalonc.exe
macOS: /Applications/Katalon Studio.app/Contents/MacOS/katalonc
Linux: /opt/katalon/katalonc
Environment: $KATALON_HOME/katalonc

Smart Healing Configuration

Configure smart healing behavior in your project:

{
  "enabled": true,
  "confidenceThreshold": 0.8,
  "maxHealingAttempts": 3,
  "reportFailures": true,
  "autoUpdateObjects": false,
  "healingStrategies": [
    "attribute_fallback",
    "xpath_optimization", 
    "css_conversion",
    "text_content_matching",
    "relative_positioning"
  ]
}

MCP Tools

Test Execution

// Execute a test suite
await mcp.callTool('katalon_execute_test_suite', {
  projectPath: '/path/to/katalon/project',
  testSuitePath: 'Test Suites/Regression Suite.ts',
  browser: 'Chrome',
  executionProfile: 'production'
});

Test Case Creation

// Create a new test case
await mcp.callTool('katalon_create_test_case', {
  projectPath: '/path/to/katalon/project',
  testCaseName: 'User_Login_Success',
  description: 'Test successful user login with valid credentials',
  testSteps: [
    'Navigate to login page',
    'Enter valid username',
    'Enter valid password', 
    'Click login button',
    'Verify successful login'
  ]
});

Object Repository Management

// Create a new object with smart healing
await mcp.callTool('katalon_manage_object_repository', {
  projectPath: '/path/to/katalon/project',
  action: 'create',
  objectName: 'login_username_field',
  selector: '#username',
  selectorType: 'css',
  smartHealingEnabled: true
});

Keyword Management

// List built-in keywords
await mcp.callTool('katalon_manage_keywords', {
  projectPath: '/path/to/katalon/project',
  action: 'list_builtin'
});

// Create custom keyword
await mcp.callTool('katalon_manage_keywords', {
  projectPath: '/path/to/katalon/project',
  action: 'create_custom',
  keywordName: 'verifyLoginSuccess',
  keywordCode: `
    WebUI.verifyElementPresent(findTestObject('Dashboard/welcome_message'), 10)
    WebUI.verifyElementText(findTestObject('Dashboard/user_name'), username)
  `
});

MCP Resources

Test Templates

Access comprehensive test case templates:

katalon://test-templates

Object Repository Best Practices

Get guidance on object identification:

katalon://object-repository-patterns

Keyword Library

Browse the complete keyword library:

katalon://keyword-library

MCP Prompts

Test Design Guidance

await mcp.getPrompt('katalon_test_design', {
  application_type: 'web',
  test_scope: 'regression'
});

Object Identification Help

await mcp.getPrompt('katalon_object_identification', {
  element_type: 'button'
});

Development

Building

npm run build        # Compile TypeScript
npm run watch        # Watch mode for development
npm run dev          # Build and run

Testing

npm test            # Run tests (when implemented)

Integration with Claude AI

This MCP server is designed to work seamlessly with Claude AI, providing:

Contextual Test Automation: Claude can understand your Katalon project structure and suggest appropriate test strategies
Intelligent Object Identification: AI-powered recommendations for robust object selectors
Smart Test Case Generation: Generate test cases based on requirements or user stories
Automated Problem Resolution: Use smart healing insights to improve test stability
Best Practice Guidance: Get AI-powered recommendations for test automation improvements

Example Claude Integration

"I need to test the checkout process for an e-commerce site. The application has dynamic element IDs that change between deployments."

Claude with Katalon MCP Server can:
- Analyze your existing test structure
- Suggest robust object identification strategies
- Create test cases with smart healing enabled
- Provide best practices for handling dynamic elements
- Generate comprehensive test data scenarios

Architecture

Katalon MCP Server
├── MCP Protocol Layer (index.ts)
│   ├── Tools (execute, create, manage)
│   ├── Resources (templates, guides, libraries)
│   └── Prompts (design guidance, best practices)
├── Katalon Integration Layer
│   ├── Project Manager (analysis, creation)
│   ├── Test Executor (execution, monitoring)
│   ├── Object Repository (management, healing)
│   ├── Keyword Manager (built-in, custom)
│   └── Smart Healing (strategies, reporting)
└── Katalon Runtime Engine Interface
    ├── Command Line Integration
    ├── Report Parsing
    └── File System Management

Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

Documentation: Katalon MCP Server Docs
Issues: GitHub Issues
Community: Katalon Community

Acknowledgments

Katalon Studio for the excellent test automation platform
Model Context Protocol for the integration framework
Anthropic Claude for AI-powered automation capabilities

Built with ❤️ for QA Automation Engineers

Available Tools

5 tools

katalon_analyze_projectC

Analyze Katalon project structure and provide insights

ParametersJSON Schema

Name	Required	Description	Default
`projectPath`	Yes	Path to the Katalon project
`analysisType`	No	Type of analysis to perform

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should fully disclose behavioral traits, but it only says 'analyze ... provide insights'. It does not state whether the tool is read-only, any side effects, or response format.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no unnecessary words, fitting the structure well.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given two parameters, no output schema, and no annotations, the description is too minimal. It does not explain analysis types, output, or prerequisites, leaving gaps for an analysis tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The tool description adds no additional meaning beyond the schema's parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb+resource ('analyze project structure') and distinguishes from siblings (which are about creation, execution, and management). However, it could be more explicit about the scope of insights.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. No when/when-not conditions or exclusions are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

katalon_create_test_caseA

Create a new test case with intelligent object identification

ParametersJSON Schema

Name	Required	Description
`projectPath`	Yes	Path to the Katalon project
`testCaseName`	Yes	Name of the new test case
`description`	Yes	Description of what the test case should do
`targetUrl`	No	Target URL for web testing (optional)
`testSteps`	No	Array of test steps with descriptions

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description bears the full burden. It mentions 'intelligent object identification' but does not explain what that entails. No contradiction with annotations (none exist). Adequate but not detailed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, concise and front-loaded. Every word earns its place, though additional detail could be included without compromising conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description is too sparse. It does not explain the return value, side effects, or how 'intelligent object identification' works, leaving the agent with incomplete context for a 5-parameter tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers 100% of parameters, so baseline is 3. The description adds no additional meaning to the parameters beyond their schema definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create a new test case') and resource, and distinguishes it from sibling tools which focus on analysis, execution, and management.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives, but the purpose is clear enough from context. No exclusions or when-not-to-use information provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

katalon_execute_test_suiteB

Execute a Katalon test suite or test suite collection with real-time monitoring

ParametersJSON Schema

Name	Required	Description	Default
`projectPath`	Yes	Full path to the Katalon project folder on your computer
`testSuitePath`	Yes	Path to the specific test suite file you want to run
`browser`	No	Which web browser to use for testing (Chrome, Firefox, Safari, Edge, etc.)	Chrome
`executionProfile`	No	Execution profile to use	default

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are available, so the description carries the full burden. It mentions 'real-time monitoring' but does not explain what that entails (e.g., status updates, cancellation, failure handling) or other behavioral aspects like permissions or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short and front-loaded with the core action. It includes the key phrase 'real-time monitoring' without unnecessary elaboration, though it could benefit from slightly more detail without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of executing a test suite with 4 parameters and no output schema or annotations, the description lacks essential details about return values, logs, process duration, or success/failure indicators, making it incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions for all parameters. The tool description does not add any additional meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Execute') and resource ('Katalon test suite or test suite collection'), and adds 'with real-time monitoring' for extra specificity. It is distinct from sibling tools which focus on analysis, creation, or management.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives, such as when to prefer analysis over execution, or any prerequisites. The description simply states what it does without contextual usage advice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

katalon_manage_keywordsC

Manage custom keywords and view built-in keywords

ParametersJSON Schema

Name	Required	Description
`projectPath`	Yes	Path to the Katalon project
`action`	Yes	Action to perform
`keywordName`	No	Name of the custom keyword (for create/update)
`keywordCode`	No	Groovy code for the custom keyword

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It only states 'manage' and 'view', omitting behavioral traits like that create/update actions modify data, potential side effects, or required permissions. The description adds minimal value beyond the schema for transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise. However, it could be restructured to front-load the specific actions (list, create, update) instead of using the vague 'manage'. It earns its place but is not optimally informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (4 parameters, multiple actions, no output schema, no annotations), the description is insufficient. It does not explain return values, how different actions work, or preconditions. An agent would lack critical context for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema's parameter descriptions. For example, it doesn't clarify the difference between 'list_builtin' and 'list_custom', or explain the format of 'keywordCode'. The description meets the baseline but adds no value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Manage custom keywords and view built-in keywords' clearly identifies the resource (keywords) and implies actions (manage, view). The action enum in the schema confirms the specific operations. It distinguishes from sibling tools like katalon_create_test_case or katalon_execute_test_suite, which deal with different resources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. Sibling tools suggest different tasks (analyzing project, creating test case), but no explicit context or exclusions are given. An agent would need to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

katalon_manage_object_repositoryC

Manage object repository with smart healing capabilities

ParametersJSON Schema

Name	Required	Description
`projectPath`	Yes	Path to the Katalon project
`action`	Yes	Action to perform on the object repository
`objectName`	No	Name of the object
`selector`	No	Object selector (XPath, CSS, ID, etc.)
`selectorType`	No	Type of selector

TDQS

C2.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description mentions 'smart healing capabilities' but does not explain what that entails (e.g., automatic selector repair). No annotations are provided, so the description carries the full burden, but it fails to disclose behavioral traits like idempotency, side effects, or permission requirements.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise, but it lacks substance. It is not front-loaded with critical information, and its brevity sacrifices clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 5 parameters, 2 enums, no output schema, and no annotations, the description should explain the purpose of each action and the tool's overall role. It fails to do so, leaving significant gaps in understanding.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers all 5 parameters with descriptions, so the description adds no extra meaning. Baseline score of 3 is appropriate given high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description identifies the resource ('object repository') and a general action ('manage'), but 'manage' is vague and does not differentiate from sibling tools like 'katalon_analyze_project' or 'katalon_manage_keywords'. The specific actions (create, update, delete, heal, analyze) are only in the schema, not in the description.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus its siblings. The description provides no context for selecting this tool over alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

5 tool updatesv1.0.0May 26, 2026
- First observedkatalon_analyze_project
- First observedkatalon_create_test_case
- First observedkatalon_execute_test_suite
- First observedkatalon_manage_keywords
- First observedkatalon_manage_object_repository

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.4/5.0

Scored 2026-05-26 22:20 across 5 tools

Disambiguation5/5

Each tool targets a distinct aspect of Katalon project management (analysis, test case creation, execution, keyword management, object repository) with no overlapping purposes.

Naming Consistency5/5

All tools follow a consistent 'katalon_verb_noun' pattern using lowercase snake_case, making the naming predictable and easy to understand.

Tool Count5/5

With 5 tools, the set is well-scoped for a Katalon automation server, covering essential operations without being too sparse or bloated.

Completeness4/5

The tool set covers core workflows (analyze, create, execute, manage keywords and objects), but is missing update/delete operations for test cases or test suites, which are minor gaps.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Katalon True Platform MCPOAuth
io.github.katalon-studio
Katalon True Platform MCP: design tests, run with AI, upload reports, assess release readiness.
Testing & QA Tools Monitoring CI/CD & DevOps
22
constantsOAuth
io.github.constants-ai
One workspace of tools for Claude and ChatGPT: connect 600+ apps, generate media, build tools.
App Automation Developer Tools Multimedia Processing
1
platform7nOAuth
tech.p7n
Connect Claude to your Platform7n workspaces — chat, links, and tasks. One-click OAuth.
Communication Project Management Workplace & Productivity
2
Cypress Cloud MCP BOAuth
io.cypress.mcp
Direct access to Cypress tests results and accessibility reports in your AI workflow.
Testing & QA Tools CI/CD & DevOps
24

Related MCP Servers

Xcode MCP Server
Developer Tools Code Execution Coding Agents
r-huijts
A
license
B
quality
F
maintenance
Bridges Claude AI with Xcode, enabling AI-powered code assistance, project management, and automated development tasks securely on your local machine.
Updated 7 months ago (2026-02-02 11:23 UTC)
76
157 npm
383
MIT
QA Studio MCP Server
Testing & QA Tools Project Management App Automation
QAStudio-Dev
A
license
A
quality
C
maintenance
Enables interaction with QA Studio test management platform directly from Claude, allowing users to manage projects, create test runs, view test results, create test cases, and submit manual test results through natural language.
Updated 9 months ago (2025-12-16 19:36 UTC)
7
8 npm
AGPL 3.0
Claude Code Starter Kit MCP
Testing & QA Tools Code Analysis Penetration Testing
dachivadachkoria
A
license
C
quality
C
maintenance
Enables AI-powered automated testing, security scanning, code review, and maintenance tasks directly within Claude Code or desktop.
Updated 6 months ago (2026-03-08 21:09 UTC)
12
4
MIT
Claude Flow MCP
Developer Tools Code Analysis AI & Machine Learning
catlog22
F
license
Not graded
quality
F
maintenance
Integrates with Claude Code to execute AI-powered code analysis and workflow automation, supporting pre-defined scenarios like code review and security audit.
Updated a year ago (2025-08-25 14:45 UTC)
5
-

Katalon MCP Server

📋 Table of Contents

🚀 Quick Start

📋 Prerequisites

Required Software

System Requirements

Katalon Setup

📦 Installation

Method 1: Clone from GitHub (Recommended)

Method 2: Download ZIP

Method 3: Automated Setup (Windows)

⚙️ Configuration

1. Environment Variables (Optional)

2. Claude Desktop Configuration

3. Verification

🚀 Usage

Starting the Server

Basic Commands in Claude

🛠️ Available Tools

1. Project Analysis

2. Test Case Management

3. Test Execution

4. Object Repository Management

5. Keyword Management

6. Smart Healing

🔧 Development

Project Structure

Available Scripts

Building from Source

✨ Features

🚀 Core Capabilities

🔧 Key Components

1. Project Manager (project-manager.ts)

2. Test Executor (test-executor.ts)

3. Object Repository Manager (object-repository.ts)

4. Keyword Manager (keyword-manager.ts)

5. Smart Healing Engine (smart-healing.ts)

🤝 Contributing

Getting Started

Development Guidelines

Submitting Changes

Commit Message Convention

🐛 Troubleshooting

Common Issues

1. Katalon Runtime Engine Not Found

2. Node.js Version Issues

3. Permission Errors (Windows)

4. TypeScript Compilation Errors

5. Claude Desktop Not Connecting

Getting Help

Debug Mode

📚 Documentation

🏗️ Architecture

🔒 Security Considerations

📄 License

🙏 Acknowledgments

4. Keyword Manager (keyword-manager.ts)

5. Smart Healing System (smart-healing.ts)

Installation

Prerequisites

Setup

Configuration

Katalon Integration

Smart Healing Configuration

MCP Tools

Test Execution

Test Case Creation

Object Repository Management

Keyword Management

MCP Resources

Test Templates

Object Repository Best Practices

Keyword Library

MCP Prompts

Test Design Guidance

Object Identification Help

Development

Building

Testing

Integration with Claude AI

1. Project Manager (`project-manager.ts`)

2. Test Executor (`test-executor.ts`)

3. Object Repository Manager (`object-repository.ts`)

4. Keyword Manager (`keyword-manager.ts`)

5. Smart Healing Engine (`smart-healing.ts`)

4. Keyword Manager (`keyword-manager.ts`)

5. Smart Healing System (`smart-healing.ts`)