de en es ja ko ru zh

Qontinui MCP Server

Name: Qontinui MCP Server
Author: qontinui

by qontinui

Overview Schema Related Servers Score Discussions

Python

Local

qontinui-mcp

Leichter MCP-Server für Qontinui Runner – ermöglicht KI-gesteuerte visuelle Automatisierung.

Installation

pip install qontinui-mcp

Related MCP server: RPA MCP Server

Schnellstart

Starten Sie den Qontinui Runner (Desktop-Anwendung)
Konfigurieren Sie Ihren KI-Client (Claude Desktop, Claude Code, Cursor, etc.)

Fügen Sie dies zu Ihrer MCP-Konfiguration hinzu:

{
  "mcpServers": {
    "qontinui": {
      "command": "qontinui-mcp",
      "args": []
    }
  }
}

Workflows über KI ausführen

Die KI kann nun:

Workflow-Konfigurationsdateien laden
Visuelle Automatisierungs-Workflows ausführen
Den Ausführungsstatus überwachen
Steuern, welcher Monitor verwendet werden soll

Konfiguration

Umgebungsvariablen:

Variable	Beschreibung	Standardwert
`QONTINUI_RUNNER_HOST`	Host-Adresse des Runners	Automatisch erkannt (WSL-fähig)
`QONTINUI_RUNNER_PORT`	HTTP-Port des Runners	`9876`
`QONTINUI_RESULTS_DIR`	Verzeichnis für Automatisierungsergebnisse	`.automation-results`
`QONTINUI_DEV_LOGS_DIR`	Verzeichnis für Entwickler-Logs	`.dev-logs`

Funktionen

Bereich A: SSE-Event-Streaming

Echtzeit-Event-Streaming über Server-Sent Events (SSE) zur Überwachung der Workflow-Ausführung.

Endpunkt: /sse/events

Client-Nutzung:

from qontinui_mcp.client import QontinuiClient

client = QontinuiClient()

def handle_event(event: dict):
    print(f"Event: {event['event_type']} - {event}")

await client.subscribe_events(callback=handle_event, timeout=60)

Event-Typen:

qontinui/execution_started - Workflow beginnt
qontinui/execution_progress - Schritt abgeschlossen
qontinui/execution_completed - Workflow endet
qontinui/test_started - Test beginnt
qontinui/test_completed - Test endet
qontinui/image_recognition - Übereinstimmung gefunden/fehlgeschlagen
qontinui/error - Fehler tritt auf
qontinui/warning - Nicht kritisches Problem

Bereich B: MCP-Prompts

Parametrisierte Prompt-Vorlagen für häufige Automatisierungsaufgaben. Prompts aggregieren Kontext vom Runner, um strukturierte Debugging-, Analyse- und Verifizierungs-Workflows bereitzustellen.

Prompt	Beschreibung	Argumente
`debug_test_failure`	Analysieren eines Testfehlers mit strukturiertem Debugging-Ansatz	`test_id` (erforderlich), `include_screenshots`
`analyze_screenshot`	Visuelle Analyse eines Screenshots zur UI-Verifizierung	`screenshot_id` (erforderlich), `focus_area`
`fix_playwright_failure`	Strukturierter Workflow zur Behebung eines fehlerhaften Playwright-Tests	`spec_name` (erforderlich), `error_message`
`verify_workflow_state`	Überprüfen, ob der aktuelle GUI-Zustand dem erwarteten Workflow-Zustand entspricht	`state_name` (erforderlich), `workflow_name`
`create_verification_test`	Generieren eines Verifizierungstests für ein UI-Verhalten	`behavior_description` (erforderlich), `test_type`
`analyze_automation_run`	Überprüfen der Ergebnisse eines Automatisierungslaufs und Identifizieren von Problemen	`run_id`, `focus_on_failures`
`debug_image_recognition`	Debuggen von Template-Matching- und Bilderkennungsproblemen	`template_name`, `last_n_attempts`
`summarize_task_progress`	Zusammenfassung des Aufgabenstatus mit Ausführungsfortschritt	`task_run_id`
`analyze_verification_failure`	Analysieren, warum ein Verifizierungskriterium fehlgeschlagen ist	`task_id` (erforderlich), `criterion_id`
`create_verification_plan`	Generieren eines Verifizierungsplans für eine Funktion	`feature_description` (erforderlich), `strategy`

Bereich C: Tool-Caching

Versionsbasiertes Tool-Caching zur Optimierung von MCP-Tool-Listenanfragen.

Endpunkt: /tool-version

Antwort:

{
  "version": "abc123...",
  "tool_count": 35,
  "test_count": 12
}

Der MCP-Server speichert Tools zwischen und invalidiert den Cache, wenn:

Die Tool-Version des Runners sich ändert (Konfiguration geladen, Tests hinzugefügt/entfernt)
Der Cache älter als 5 Minuten ist (Fallback)

Bereich E: Berechtigungssystem

Feingranulare Berechtigungskontrolle für Tool-Aufrufe, inspiriert vom Berechtigungssystem von OpenCode.

Berechtigungsstufen:

Stufe	Beschreibung	Beispiel-Tools
`READ_ONLY`	Sichere Operationen, die nur Daten lesen	`get_executor_status`, `list_monitors`, `read_runner_logs`
`EXECUTE`	Operationen, die Workflows oder Tests ausführen	`run_workflow`, `execute_test`, `execute_python`
`MODIFY`	Operationen, die Daten ändern	`create_test`, `update_test`, `load_config`
`DANGEROUS`	Operationen, die die Ausführung stören können	`stop_execution`, `restart_runner`

Konfiguration:

from qontinui_mcp.permissions import get_permission_service, PermissionLevel

service = get_permission_service()

# Auto-approve only read operations (default)
service.configure(auto_approve_levels={PermissionLevel.READ_ONLY})

# Auto-approve all operations (trusted context)
service.auto_approve_all()

# Custom permission handler
service.on_request = lambda req: input(f"Allow {req.tool_name}? (y/n)") == "y"

Bereich F: MCP-Ressourcen

Schreibgeschützter Datenzugriff über URI-Schema für den Zugriff auf Runner-Daten.

URI-Schema: qontinui://{type}/{id}

Ressourcentypen:

URI-Muster	Beschreibung	MIME-Typ
`qontinui://config/current`	Aktuell geladene Workflow-Konfiguration	`application/json`
`qontinui://logs/{type}`	JSONL-Logdateien (allgemein, Aktionen, Bilderkennung, Playwright)	`application/jsonl`
`qontinui://screenshots/{id}`	Screenshot-Metadaten und Dateipfade	`image/png`
`qontinui://tests/{id}`	Definitionen von Verifizierungstests	`application/json`
`qontinui://dom/{id}`	DOM-Capture HTML-Inhalt	`text/html`
`qontinui://task-runs/{id}`	Details zum Aufgabenlauf	`application/json`

Bereich G: Inline-Python-Ausführung

Ausführen von beliebigem Python-Code mit optionaler Abhängigkeitsisolierung über uvx.

Tool: execute_python

Parameter:

code (erforderlich): Auszuführender Python-Code
dependencies: Liste der zu installierenden Pip-Pakete
timeout_seconds: Ausführungs-Timeout (Standard: 30)
working_directory: Arbeitsverzeichnis für die Ausführung

Beispiel:

# Simple calculation
result = await client.execute_python(
    code="return {'sum': 1 + 2, 'product': 3 * 4}"
)
# result.data["return_value"] == {"sum": 3, "product": 12}

# With dependencies
result = await client.execute_python(
    code="""
    import requests
    resp = requests.get('https://api.example.com/data')
    return resp.json()
    """,
    dependencies=["requests"],
)

Bereich H: Agent-Spawning

Hierarchische Aufgabendekomposition durch das Erzeugen von Sub-Agenten mit fokussierten Aufgaben.

Tool: spawn_sub_agent

Parameter:

task (erforderlich): Aufgabenbeschreibung für den Sub-Agenten
tools: Liste der Tool-Namen, auf die der Sub-Agent beschränkt werden soll
max_iterations: Maximale Anzahl an Durchläufen/Iterationen (Standard: 10)
context: Zusätzlicher bereitzustellender Kontext

Beispiel:

result = await client.spawn_sub_agent(
    task="Verify that the login form works correctly",
    tools=["run_workflow", "capture_screenshot", "execute_test"],
    max_iterations=5,
    context="The login page is at /login with username and password fields."
)

Verfügbare Tools

Core-Tools

Tool	Berechtigung	Beschreibung
`get_executor_status`	READ_ONLY	Runner-Status abrufen
`list_monitors`	READ_ONLY	Verfügbare Monitore auflisten
`load_config`	MODIFY	Workflow-Konfigurationsdatei laden
`ensure_config_loaded`	MODIFY	Konfiguration laden, falls noch nicht geschehen
`get_loaded_config`	READ_ONLY	Informationen zur geladenen Konfiguration abrufen
`run_workflow`	EXECUTE	Workflow nach Namen ausführen
`stop_execution`	DANGEROUS	Aktuelle Ausführung stoppen

Aufgabenmanagement-Tools

Tool	Berechtigung	Beschreibung
`get_task_runs`	READ_ONLY	Alle Aufgabenläufe abrufen
`get_task_run`	READ_ONLY	Details zu einem bestimmten Aufgabenlauf abrufen
`get_task_run_events`	READ_ONLY	Events für einen Aufgabenlauf abrufen
`get_task_run_screenshots`	READ_ONLY	Screenshots für einen Aufgabenlauf abrufen
`get_task_run_playwright_results`	READ_ONLY	Playwright-Ergebnisse für einen Aufgabenlauf abrufen
`migrate_task_run_logs`	EXECUTE	JSONL-Logs nach SQLite migrieren

Automatisierungslauf-Tools

Tool	Berechtigung	Beschreibung
`get_automation_runs`	READ_ONLY	Letzte Automatisierungsläufe abrufen
`get_automation_run`	READ_ONLY	Details zu einem bestimmten Automatisierungslauf abrufen

Testmanagement-Tools

Tool	Berechtigung	Beschreibung
`list_tests`	READ_ONLY	Alle Verifizierungstests auflisten
`get_test`	READ_ONLY	Test nach ID abrufen
`execute_test`	EXECUTE	Verifizierungstest ausführen
`list_test_results`	READ_ONLY	Testergebnisse auflisten
`get_test_history`	READ_ONLY	Zusammenfassung der Testhistorie abrufen
`create_test`	MODIFY	Neuen Verifizierungstest erstellen
`update_test`	MODIFY	Bestehenden Test aktualisieren
`delete_test`	MODIFY	Verifizierungstest löschen

Testtypen:

playwright_cdp - Browser-DOM-Assertions mittels Playwright
qontinui_vision - Visuelle Verifizierung mittels Bilderkennung
python_script - Benutzerdefinierte Python-Verifizierungslogik
repository_test - Ausführen von pytest, Jest oder anderen Test-Frameworks

Log-Tools

Tool	Berechtigung	Beschreibung
`list_screenshots`	READ_ONLY	Verfügbare Screenshots auflisten
`read_runner_logs`	READ_ONLY	Runner JSONL-Logdateien lesen

Logtypen:

general - Allgemeine Executor-Events
actions - Workflow-Aktions-/Baum-Events
image-recognition - Bilderkennungsergebnisse mit Übereinstimmungsdetails
playwright - Ergebnisse der Playwright-Testausführung

DOM-Capture-Tools

Tool	Berechtigung	Beschreibung
`list_dom_captures`	READ_ONLY	DOM-Captures auflisten
`get_dom_capture`	READ_ONLY	DOM-Capture-Metadaten abrufen
`get_dom_capture_html`	READ_ONLY	DOM-Capture HTML-Inhalt abrufen

AWAS (AI Web Action Standard) Tools

Tools für die Interaktion mit Websites, die den AWAS-Standard unterstützen.

Tool	Berechtigung	Beschreibung
`awas_discover`	EXECUTE	AWAS-Manifest für eine Website entdecken
`awas_check_support`	READ_ONLY	Prüfen, ob eine Website AWAS unterstützt
`awas_list_actions`	READ_ONLY	Verfügbare AWAS-Aktionen auflisten
`awas_execute`	EXECUTE	AWAS-Aktion ausführen

Erweiterte Tools

Tool	Berechtigung	Beschreibung
`execute_python`	EXECUTE	Inline-Python-Code ausführen
`spawn_sub_agent`	EXECUTE	Sub-Agent mit einer spezifischen Aufgabe erzeugen

Anwendungsbeispiel

Grundlegende Workflow-Ausführung

# In an AI conversation:
"Load the config at /path/to/workflow.json and run the 'login_test' workflow on the left monitor"

Testgesteuerte Verifizierung

# Create a verification test
"Create a Playwright test that verifies the login button is visible and enabled"

# Execute the test
"Run the login_button_visible test and show me the results"

# Debug failures
"Use the debug_test_failure prompt for test abc123 with screenshots"

Automatisierungsanalyse

# Analyze a failed automation run
"Analyze the most recent automation run and identify why it failed"

# Debug image recognition
"Debug the template matching for the 'submit_button' template"

Entwicklung

# Clone
git clone https://github.com/qontinui/qontinui-mcp
cd qontinui-mcp

# Install dependencies
poetry install

# Run server locally
poetry run qontinui-mcp

# Run type checking
poetry run mypy src/

# Run linting
poetry run ruff check src/

Architektur

qontinui-mcp (MCP Server)
    |
    v
QontinuiClient (HTTP Client)
    |
    v
qontinui-runner (Desktop App, port 9876)
    |
    v
Python Subprocess (Qontinui Execution)

Der MCP-Server ist ein schlanker Wrapper, der:

Runner-Funktionen über das MCP-Protokoll bereitstellt
Berechtigungskontrolle für Tool-Aufrufe bietet
Tool-Definitionen für die Performance zwischenspeichert
Kontext für strukturierte Prompts aggregiert
Events über SSE für Echtzeitüberwachung streamt

Lizenz

Lizenziert unter der GNU Affero General Public License v3.0 oder höher (AGPL-3.0-or-later). Siehe LICENSE für die vollständigen Bedingungen.

This server cannot be installed

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

studio
io.kaitoi
Build and run visual creative-production workflows from your AI agent.
AI & Machine Learning Design Tools App Automation
2
Dobby
io.github.gil-dobby
Connect, monitor, and control AI agents — tasks, approvals, schedules, and governance.
Agent Orchestration Autonomous Agents Monitoring
2
Goodeye A
dev.goodeye
Design, save, and run outcome-aligned AI workflows and verifiers, with reliable image output.
Agent Orchestration AI & Machine Learning Image & Video Processing
24
mcp-server
com.make
Give your AI agents the tools to build, manage, and run automation workflows.
App Automation Developer Tools Workplace & Productivity
2

Related MCP Servers

Qontinui Web MCP Server
App Automation Project Management
qontinui
A
license
Not graded
quality
C
maintenance
Enables AI assistants to create and manage visual automation configurations, workflows, and UI states through the Qontinui API. It supports project management, workflow execution, and configuration handling for automated web interactions.
Updated 17 days ago (2026-08-18 03:25 UTC)
AGPL 3.0
RPA MCP Server
OS Automation Browser Automation App Automation
macbeth76
F
license
Not graded
quality
Not graded
maintenance
Provides comprehensive desktop automation capabilities including AI-powered vision, OCR, and mouse/keyboard control via a Spring Boot REST API. It enables users to execute multi-step workflows, manage files, and automate browser interactions.
Updated 6 months ago (2026-02-22 01:39 UTC)
UI Bridge MCP
Testing & QA Tools App Automation
qontinui
A
license
Not graded
quality
C
maintenance
Enables AI to inspect and interact with UI elements, supporting control mode for the runner's own UI and SDK mode for external applications.
Updated a month ago (2026-07-29 05:08 UTC)
AGPL 3.0
qontinui-lib-mcpofficial
OS Automation App Automation Testing & QA Tools
qontinui
A
license
Not graded
quality
B
maintenance
Enables AI-powered visual automation workflows by providing tools for searching nodes, creating and validating workflows, and executing automation scripts via natural language.
Updated 2 days ago (2026-09-01 14:19 UTC)
AGPL 3.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/qontinui/qontinui-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server