Skip to main content
Glama

🤖 DroidMind 🧠

Python 3.13+ Lizenz Status Codestil Typprüfung MCP Android Dokumente

Steuern Sie Android-Geräte mit KI über das Model Context Protocol

DroidMind ist eine leistungsstarke Brücke zwischen KI-Assistenten und Android-Geräten und ermöglicht Steuerung, Debugging und Systemanalyse mithilfe natürlicher Sprache. Durch die Implementierung des Model Context Protocol (MCP) ermöglicht DroidMind KI-Modellen die sichere und strukturierte direkte Interaktion mit Android-Geräten über ADB. Im Rahmen eines agentenbasierten Coding-Workflows ermöglicht DroidMind Ihrem Assistenten das direkte Erstellen und Debuggen mit Ihrem Gerät.

💫 Kernfunktionen

DroidMind ermöglicht KI-Assistenten Folgendes:

  • 📱 Geräte verwalten : Über USB/TCP-IP verbinden, Geräte auflisten, Eigenschaften anzeigen und neu starten.

  • 📊 Systeme analysieren : Auf Protokolle zugreifen (Logcat, ANR, Absturz, Batterie), Fehlerberichte erfassen und Heap sichern.

  • 📂 Dateien verwalten : Gerätedateien/-verzeichnisse durchsuchen, lesen, schreiben, pushen, pullen, löschen und verwalten.

  • 📦 Apps steuern : Installieren, deinstallieren, starten, stoppen, Daten löschen und App-Details überprüfen (Manifest, Berechtigungen, Aktivitäten).

  • 🖼️ Benutzeroberfläche automatisieren : Tippen, Wischen, Texteingabe und Tastendrücken durchführen.

  • 🐚 Shell-Befehle ausführen : Führen Sie ADB-Shell-Befehle mit einem sicherheitsbewussten Framework aus.

  • 🔒 Sicherer Betrieb : Profitieren Sie von Befehlsvalidierung, Risikobewertung und Bereinigung.

  • 💬 Nahtlose Integration : Verbindung mit jedem MCP-kompatiblen Client (Claude, Cursor, Cline usw.).

Eine detaillierte Liste der Funktionen finden Sie im Benutzerhandbuch und in der MCP-Referenz .

Related MCP server: MCP Android Agent

🚀 Erste Schritte

Schnellstart für IDEs (Zero Install mit uvx )

Um DroidMind am schnellsten in eine MCP-kompatible IDE (wie Cursor) zu integrieren, können Sie diese so konfigurieren, dass DroidMind mithilfe von uvx direkt aus dem GitHub-Repository ausgeführt wird. Bei dieser Methode ist kein manuelles Klonen oder Installieren von DroidMind erforderlich .

Fügen Sie der MCP-Konfiguration Ihrer IDE Folgendes hinzu (z. B. .cursor/mcp.json für Cursor):

{
  "mcpServers": {
    "droidmind": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/hyperb1iss/droidmind",
        "droidmind",
        "--transport",
        "stdio" // The default and preferred mode for most IDE integrations
      ]
    }
  }
}

Ihre IDE wird so konfiguriert, dass DroidMind bei Bedarf gestartet wird. Eine vollständige Anleitung zur Einrichtung finden Sie in der Kurzanleitung .

Voraussetzungen

  • Python 3.13 oder höher

  • uv (Python-Paketmanager)

  • Android-Gerät mit aktiviertem USB-Debugging

  • ADB (Android Debug Bridge) installiert und im PATH Ihres Systems

Installation

Ausführliche Anweisungen zum Einrichten von DroidMind, einschließlich der schnellen IDE-Integration mit uvx (behandelt im Schnellstart), der manuellen Installation aus der Quelle oder der Verwendung von Docker, finden Sie in unserem umfassenden Installationshandbuch .

DroidMind ausführen

Wie Sie DroidMind ausführen, hängt von Ihrem Setup ab:

  • IDE-Integration (über uvx ) : Ihre IDE verwaltet die Ausführung von DroidMind automatisch gemäß den MCP-Einstellungen (z. B. mcp.json ). Weitere Informationen finden Sie in der Kurzanleitung .

  • Manuelle Installation : Nach der Installation aus der Quelle können Sie DroidMind direkt ausführen.

    • Stdio (für direkte Terminalinteraktion oder einige IDE-Setups):

      droidmind --transport stdio
    • SSE (für Web-Benutzeroberflächen oder KI-Assistenten wie Claude Desktop):

      droidmind --transport sse

      Dadurch wird normalerweise ein Server unter sse://localhost:4256/sse gestartet.

  • Docker : Befehle zum Ausführen von DroidMind in einem Container finden Sie im Docker-Handbuch .

Weitere Einzelheiten zum Ausführen von DroidMind in verschiedenen Umgebungen finden Sie im Installationshandbuch .

🐳 Ausführen mit Docker

DroidMind kann auch mit Docker ausgeführt werden, um eine konsistente, containerisierte Umgebung zu schaffen. Dies ist besonders nützlich für die Bereitstellung und Isolierung von Abhängigkeiten.

Umfassende Anweisungen zum Erstellen des Docker-Images und zum Ausführen von DroidMind in einem Container mit stdio oder SSE Transport, einschließlich Hinweisen zum ADB-Gerätezugriff, finden Sie in unserem Docker-Handbuch .

🔮 Beispiele für KI-Assistentenabfragen

Mit einem mit DroidMind verbundenen KI-Assistenten können Sie Anfragen stellen wie:

  • "Listet alle verbundenen Android-Geräte auf und zeigt ihre Eigenschaften an."

  • „Mach einen Screenshot von meinem Pixel.“

  • „Installieren Sie dieses APK auf emulator-5554 .“

  • „Zeigen Sie mir die letzten Absturzprotokolle von your_device_serial .“

  • „Tippen Sie auf dem aktuellen Bildschirm des emulator-5554 auf die Schaltfläche ‚Weiter‘.“

Weitere Inspiration finden Sie in unseren Beispielabfragen und -workflows im Benutzerhandbuch.

🔒 Sicherheit

DroidMind enthält ein Sicherheitsframework zum Schutz Ihrer Geräte:

  • Befehlsvalidierung und -bereinigung

  • Kategorisierung der Risikobewertung

  • Geschützte Pfadvorgänge

  • Umfassende Protokollierung

Hochriskante Vorgänge werden gekennzeichnet und kritische Vorgänge standardmäßig blockiert. Weitere Informationen finden Sie im Kapitel „Sicherheitshinweise“ .

💻 Entwicklung

DroidMind verwendet uv für Abhängigkeitsmanagement und Entwicklungs-Workflows.

# Install/update dependencies (after cloning and activating .venv)
uv pip install -e .[dev,sse]

# Run tests
pytest

# Run linting
ruff check .

# Run type checking
pyright # Ensure pyright is installed or use ruff's type checking capabilities

🤝 Beitragen

Beiträge sind willkommen! Senden Sie gerne einen Pull Request.

  1. Forken Sie das Repository.

  2. Erstellen Sie Ihren Feature-Zweig ( git checkout -b feature/amazing-feature ).

  3. Richten Sie Ihre Entwicklungsumgebung mit uv ein.

  4. Nehmen Sie Ihre Änderungen vor.

  5. Führen Sie Tests, Lint-Tests und Typprüfungen durch.

  6. Übernehmen Sie Ihre Änderungen ( git commit -m 'Add some amazing feature' ).

  7. Pushen Sie zum Zweig ( git push origin feature/amazing-feature ).

  8. Öffnen Sie eine Pull-Anfrage.

📝 Lizenz

Dieses Projekt ist unter der Apache-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .


Erstellt von Stefanie Jane 🌠

Wenn Sie DroidMind nützlich finden, kaufen Sie mir ein Monster Ultra Violet ⚡️

Available Tools

8 tools
android-appA

Perform various application management operations on an Android device.

This single tool consolidates various app-related actions. The 'action' parameter determines the operation.

Args: serial: Device serial number. action: The specific app operation to perform. ctx: MCP Context for logging and interaction. package (Optional[str]): Package name for the target application. Required by most actions. apk_path (Optional[str]): Path to the APK file (local to the server). Used by install_app. reinstall (Optional[bool]): Whether to reinstall if app exists. Used by install_app. grant_permissions (Optional[bool]): Whether to grant all requested permissions. Used by install_app. keep_data (Optional[bool]): Whether to keep app data and cache directories. Used by uninstall_app. activity (Optional[str]): Optional activity name to start. Used by start_app. extras (Optional[dict[str, str]]): Optional intent extras. Used by start_intent. include_system_apps (Optional[bool]): Whether to include system apps. Used by list_packages. include_app_name (Optional[bool]): Whether to include app labels (best-effort). Used by list_packages. include_apk_path (Optional[bool]): Whether to include APK paths. Used by list_packages. max_packages (Optional[int]): Max packages to return. Used by list_packages.

Returns: A string message indicating the result or status of the operation.


Available Actions and their specific argument usage:

  1. action="install_app"

    • Requires: apk_path

    • Optional: reinstall, grant_permissions

  2. action="uninstall_app"

    • Requires: package

    • Optional: keep_data

  3. action="start_app"

    • Requires: package

    • Optional: activity 3b. action="start_intent"

    • Requires: package, activity

    • Optional: extras

  4. action="stop_app"

    • Requires: package

  5. action="clear_app_data"

    • Requires: package

  6. action="list_packages"

    • Optional: include_system_apps, include_app_name, include_apk_path, max_packages

  7. action="get_app_manifest"

    • Requires: package

  8. action="get_app_permissions"

    • Requires: package

  9. action="get_app_activities"

    • Requires: package

  10. action="get_app_info"

    • Requires: package


Inputs: serial (required), action (required), package, apk_path, +9 more. Returns: result

android-deviceA

Perform various device management operations on Android devices.

This single tool consolidates various device-related actions. The 'action' parameter determines the operation.

Args: action: The specific device operation to perform. ctx: MCP Context for logging and interaction. serial (Optional[str]): Device serial number. Required by most actions except connect/list. ip_address (Optional[str]): IP address for 'connect_device' action. port (Optional[int]): Port for 'connect_device' action (default: 5555). mode (Optional[str]): Reboot mode for 'reboot_device' action (default: "normal").

Returns: A string message indicating the result or status of the operation.


Available Actions and their specific argument usage:

  1. action="list_devices"

    • No specific arguments required beyond ctx.

  2. action="connect_device"

    • Requires: ip_address

    • Optional: port

  3. action="disconnect_device"

    • Requires: serial

  4. action="reboot_device"

    • Requires: serial

    • Optional: mode (e.g., "normal", "recovery", "bootloader")

  5. action="device_properties"

    • Requires: serial


Inputs: action (required), serial, ip_address, port, +1 more. Returns: result

android-diagA

Perform diagnostic operations like capturing bug reports or heap dumps.

Args: ctx: MCP Context. serial: Device serial number. action: The diagnostic action to perform. output_path: Optional. Path to save the output file. For bugreport: host path for adb to write the .zip. If empty, a temp file is used & summarized. For dump_heap: local path to save the .hprof. If empty, a temp file is used. include_screenshots: For CAPTURE_BUGREPORT. Default True. package_or_pid: For DUMP_HEAP. App package name or process ID. native: For DUMP_HEAP. True for native (C/C++) heap, False for Java. Default False. timeout_seconds: Max time for the operation. If 0, action-specific defaults are used (bugreport: 300s, dump_heap: 120s).

Returns: A string message indicating the result or path to the output.

Inputs: serial (required), action (required), output_path, include_screenshots, +3 more. Returns: result

android-fileA

Perform file and directory operations on an Android device.

This single tool consolidates various file system actions. The 'action' parameter determines the operation.

Args: serial: Device serial number. action: The specific file operation to perform. See available actions below. ctx: MCP Context for logging and interaction. path (Optional[str]): General path argument on the device. Used by: list_directory, delete_file, create_directory, file_exists, file_stats. Can also be used by read_file and write_file as an alternative to 'device_path'. local_path (Optional[str]): Path on the DroidMind server machine. Used by: push_file (source), pull_file (destination). device_path (Optional[str]): Path on the Android device. Used by: push_file (destination), pull_file (source), read_file (source), write_file (destination). If 'path' is also provided for read/write, 'device_path' takes precedence. content (Optional[str]): Text content to write. Used by: write_file. max_size (Optional[int]): Maximum file size in bytes for read_file (default: 100KB). Used by: read_file.

Returns: Union[str, bool]: A string message indicating the result or status for most actions. Returns a boolean for the 'file_exists' action.


Available Actions and their specific argument usage:

  1. action="list_directory": Lists contents of a directory.

    • Requires: path (directory path on device).

    • Returns: Formatted string of directory contents.

  2. action="push_file": Uploads a file from the local server to the device.

    • Requires: local_path (source on server), device_path (destination on device).

    • Returns: String message confirming upload.

  3. action="pull_file": Downloads a file from the device to the local server.

    • Requires: device_path (source on device), local_path (destination on server).

    • Returns: String message confirming download.

  4. action="delete_file": Deletes a file or directory from the device.

    • Requires: path (path to delete on device).

    • Returns: String message confirming deletion.

  5. action="create_directory": Creates a directory on the device.

    • Requires: path (directory path to create on device).

    • Returns: String message confirming creation.

  6. action="file_exists": Checks if a file or directory exists on the device.

    • Requires: path (path to check on device).

    • Returns: True if exists, False otherwise.

  7. action="read_file": Reads the contents of a file from the device.

    • Requires: device_path (or path) for the file on device.

    • Optional: max_size (defaults to 100KB).

    • Returns: String containing file contents or error message.

  8. action="write_file": Writes text content to a file on the device.

    • Requires: device_path (or path) for the file on device, content (text to write).

    • Returns: String message confirming write.

  9. action="file_stats": Gets detailed statistics for a file or directory.

    • Requires: path (path on device).

    • Returns: Markdown-formatted string of file/directory statistics.


Inputs: serial (required), action (required), path, local_path, +3 more. Returns: result

android-logA

Perform various log retrieval operations on an Android device.

This single tool consolidates various log-related actions. The 'action' parameter determines the operation.

Args: serial: Device serial number. action: The specific log operation to perform. ctx: MCP Context for logging and interaction. package (Optional[str]): Package name for get_app_logs action. lines (int): Number of lines to fetch for logcat actions (default: 1000). filter_expr (Optional[str]): Logcat filter expression for get_device_logcat. buffer (Optional[str]): Logcat buffer for get_device_logcat (default: "main"). format_type (Optional[str]): Logcat output format for get_device_logcat (default: "threadtime"). max_size (Optional[int]): Max output size for get_device_logcat (default: 100KB).

Returns: A string message containing the requested logs or status.


Available Actions and their specific argument usage:

  1. action="get_device_logcat"

    • Optional: lines, filter_expr, buffer, format_type, max_size.

  2. action="get_app_logs"

    • Requires: package.

    • Optional: lines.

  3. action="get_anr_logs"

    • No specific arguments beyond serial and ctx.

  4. action="get_crash_logs"

    • No specific arguments beyond serial and ctx.

  5. action="get_battery_stats"

    • No specific arguments beyond serial and ctx.


Inputs: serial (required), action (required), package, lines, +4 more. Returns: result

android-screenshotA

Get a screenshot from a device.

Args: serial: Device serial number ctx: MCP context quality: JPEG quality (1-100, lower means smaller file size)

Returns: The device screenshot as an image

Inputs: serial (required), quality.

android-shellA

Run a shell command on the device.

Args: serial: Device serial number command: Shell command to run max_lines: Maximum lines of output to return (default: 1000) Use positive numbers for first N lines, negative for last N lines Set to None for unlimited (not recommended for large outputs) max_size: Maximum output size in characters (default: 100000) Limits total response size regardless of line count

Returns: Command output

Inputs: serial (required), command (required), max_lines, max_size. Returns: result

android-uiB

Perform various UI interaction operations on an Android device.

Args: ctx: MCP Context. serial: Device serial number. action: The UI action to perform. x: X coordinate (for tap). y: Y coordinate (for tap). start_x: Starting X coordinate (for swipe). start_y: Starting Y coordinate (for swipe). end_x: Ending X coordinate (for swipe). end_y: Ending Y coordinate (for swipe). duration_ms: Duration of the swipe in milliseconds (default: 300). text: Text to input (for input_text). keycode: Android keycode to press (for press_key). package: Package name (for start_intent). activity: Activity name (for start_intent). extras: Optional intent extras (for start_intent).

Returns: A string message indicating the result of the operation.

Inputs: serial (required), action (required), x, y, +10 more. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 8 tools

    Disambiguation3/5

    The top-level tools are clearly categorized, but the internal actions within each mega-tool can overlap (e.g., start_intent appears in both android-app and android-ui), causing potential ambiguity for an agent. Additionally, the bundling of many operations under one tool name makes it less obvious which tool handles a specific action.

    Naming Consistency5/5

    All tool names follow a consistent 'android-<category>' pattern, and internal actions use a uniform snake_case style. The naming is predictable and readable across the entire server.

    Tool Count4/5

    With 8 tools, the count is reasonable for an Android device management server. However, the bundling of many actions into each tool makes the surface feel slightly under-tooled, though still within the effective range.

    Completeness4/5

    The tool set covers major areas: app management, device control, diagnostics, file operations, logs, screenshots, shell, and UI. Some gaps exist (e.g., network or settings management), but the core workflows for common Android tasks are well addressed.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that enables AI agents to control and automate Android devices through natural language, supporting actions like app management, UI interactions, and device monitoring.
      60
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      A MCP server that enables AI assistants to control Android devices via ADB, supporting device info, screen control, input simulation, app management, shell execution, file transfer, and UI parsing.
      20
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that wraps Android ADB functionality into AI assistant tools, enabling device management, shell execution, file operations, app management, media capture, and log analysis via natural language.
      23 npm
      3
      MIT