# Native DevTools **Category:** ๐Ÿ’ป Developer Tools **Repository:** https://github.com/sh3ll3x3c/native-devtools-mcp **Views:** 0 **Installs:** 0 **Upvotes:** 0 **Directory Page:** https://allmcps.com/mcp/native-devtools ## Description MCP server for desktop, browser (CDP), and Android automation. Screenshot, OCR, click, type. ## Claude Desktop Quick Installation Heuristic fallback โ€” verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low): ```json "mcpServers": { "native-devtools": { "command": "npx", "args": ["-y","native-devtools"] } } ``` ## Documentation & README # native-devtools-mcp > **An MCP server for computer use on native desktop and mobile apps โ€” macOS, Windows, Android, and Chrome/Electron via CDP.** ![Version](https://img.shields.io/npm/v/native-devtools-mcp?style=flat-square) ![License](https://img.shields.io/npm/l/native-devtools-mcp?style=flat-square) ![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Windows%20%7C%20Android-blue?style=flat-square) ![Downloads](https://img.shields.io/npm/dt/native-devtools-mcp?style=flat-square) **Add to your client in one click:** [![Add to Cursor](https://img.shields.io/badge/Add%20to-Cursor-000000?style=flat-square)](cursor://anysphere.cursor-deeplink/mcp/install?name=native-devtools&config=eyJjb21tYW5kIjogIm5weCIsICJhcmdzIjogWyIteSIsICJuYXRpdmUtZGV2dG9vbHMtbWNwIl19) [![Install in VS Code](https://img.shields.io/badge/Install%20in-VS%20Code-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=native-devtools&config=%7B%22name%22%3A%20%22native-devtools%22%2C%20%22command%22%3A%20%22npx%22%2C%20%22args%22%3A%20%5B%22-y%22%2C%20%22native-devtools-mcp%22%5D%7D) **Claude Code:** `claude mcp add native-devtools -- npx -y native-devtools-mcp` `native-devtools-mcp` gives AI agents and MCP clients direct control over native desktop apps, Chrome/Electron browsers, and Android devices โ€” screenshots, OCR, accessibility-first element lookup, input simulation, window management, Chrome DevTools Protocol (CDP), and ADB โ€” all in one local server. Works with [Claude Desktop](https://claude.ai/download), [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [Cursor](https://cursor.com), and other MCP-compatible clients. ## Quickstart ```bash npx -y native-devtools-mcp ```
macOS Windows
macOS Demo Windows Demo
--- ## ๐Ÿš€ Features - **๐Ÿ‘€ Computer Vision:** Screenshots of screens, windows, or regions with built-in OCR (Vision on macOS, Windows Media OCR on Windows). - **๐Ÿ–ฑ๏ธ Input Simulation:** Click, drag, scroll, type โ€” global coordinates, window-relative, and screenshot-relative targeting. - **๐ŸŽฏ Element-Precise AX Dispatch (macOS):** `take_ax_snapshot` โ†’ `ax_click` / `ax_set_value` / `ax_select` โ€” dispatch against Accessibility-tree elements without moving the mouse or stealing focus. The preferred path for native macOS apps. - **๐ŸŒ Browser Automation (CDP):** Chrome DevTools Protocol for Chrome and Electron apps (Signal, Discord, VS Code, Slack) โ€” DOM-level click, fill, navigate, and JS evaluation without a separate Node.js server. - **๐Ÿ“ฑ Android (ADB):** Screenshots, uiautomator-based text lookup, input, and app management over USB or Wi-Fi. - **๐Ÿงฉ Template Matching:** `load_image` + `find_image` for icons, toggles, and custom controls OCR can't identify. - **๐ŸชŸ Window Management:** List, focus, launch, and quit apps; record windows as timestamped JPEG frames. - **๐Ÿ” Hover Tracking:** Observe user navigation patterns with dwell-filtered hover events โ€” designed for LLMs watching a user work. - **๐Ÿ”’ Local & Private:** 100% local execution. Screenshots and input never leave your machine. ## ๐Ÿงญ Three Approaches to Interaction Pick the approach that matches your target app. | Approach | Best for | Key tools | |-----------------------|--------------------------------------------------------------------------|-------------------------------------------------------------------------| | **Visual** (universal)| Any app โ€” games, Qt, custom renderers, anything without an AX tree | `take_screenshot`, `find_text`, `click`, `type_text`, `find_image` | | **AX Dispatch** (macOS โ€” *preferred for native macOS apps*) | AppKit / SwiftUI apps โ€” System Settings, Finder, Mail, Xcode, Notes | `take_ax_snapshot`, `ax_click`, `ax_set_value`, `ax_select` | | **CDP** (Chrome / Electron) | Web content, Electron apps with `--remote-debugging-port` | `cdp_connect`, `cdp_find_elements`, `cdp_take_dom_snapshot`, `cdp_click`, `cdp_fill` | > For macOS native apps, **AX Dispatch is the preferred path** โ€” it's element-precise, doesn't move the mouse, and doesn't steal focus. See the [Native App AX Dispatch recipe](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/native-app-ax-dispatch-flow.md). There's also a fourth, niche path: **AppDebugKit** (`app_connect` / `app_query` / `app_click`) for apps instrumented with the AppDebugKit library. Mostly useful for developers testing their own apps. ## ๐Ÿ†š How it compares The most honest peers are other **MCP servers for computer use**. This table compares `native-devtools-mcp` against the leading MCP servers and two widely used non-MCP libraries. | Capability | native-devtools-mcp | [Playwright MCP][pw-mcp] | [Windows-MCP][win-mcp] | [Appium][appium] | [pywinauto][pwa] | |--------------------------------|:-------------------:|:------------------------:|:----------------------:|:----------------:|:----------------:| | Native macOS apps | โœ… AX + screenshots | โŒ browser only | โŒ Windows only | โŒ mobile focus | โŒ Windows only | | Native Windows apps | โœ… UIA + input | โŒ browser only | โœ… | โ— limited | โœ… | | Web / DOM automation | โœ… via CDP | โœ… | โ— via Windows UIA | โ— mobile-web | โŒ | | Electron apps | โœ… CDP + AX | โœ… first-class `_electron`| โ— if UIA exposed | โŒ | โ— if UIA exposed | | Android devices (ADB) | โœ… built-in | โ— experimental | โŒ | โœ… first-class | โŒ | | MCP-native | โœ… | โœ… | โœ… | โŒ | โŒ | | Local, no API key | โœ… | โœ… | โœ… | โœ… self-hosted | โœ… | [pw-mcp]: https://github.com/microsoft/playwright-mcp [win-mcp]: https://github.com/CursorTouch/Windows-MCP [appium]: https://github.com/appium/appium [pwa]: https://github.com/pywinauto/pywinauto **Where `native-devtools-mcp` stands out:** one local MCP server covering macOS + Windows + Chrome/Electron (CDP) + Android in the same session, plus element-precise macOS AX dispatch that doesn't move the cursor or steal focus. **Honest limits:** - **No Linux** (contributions welcome โ€” see [Linux Desktop MCP](https://github.com/BeckhamLabsLLC/linux-desktop-mcp) for an AT-SPI2-based alternative in the meantime) - **Browser automation is Chrome / Electron only** via CDP โ€” no Firefox, no WebKit (for those, use [Playwright MCP][pw-mcp]) - **Headed only** โ€” depends on real-machine permissions; not a headless CI test grid - **No iOS** If you need *just* web automation, [Playwright MCP][pw-mcp] is more mature. If you need *just* mobile (iOS + Android + deep device features), [Appium][appium] is more mature. This server is for the cross-cutting native-desktop + Chrome/Electron + Android case. ## ๐Ÿ“ฆ Installation The install steps are identical on macOS and Windows. ### Option 1: Run with `npx` (no install needed) ```bash npx -y native-devtools-mcp ``` ### Option 2: Global install ```bash npm install -g native-devtools-mcp ``` ### Option 3: Build from source (Rust)
Click to expand build instructions **Using the build script** (clones, builds, and runs setup): ```bash curl -fsSL https://raw.githubusercontent.com/sh3ll3x3c/native-devtools-mcp/master/scripts/build-from-source.sh | bash ``` **Or manually:** ```bash git clone https://github.com/sh3ll3x3c/native-devtools-mcp cd native-devtools-mcp cargo build --release # Binary: ./target/release/native-devtools-mcp ```
### Manual configuration (without the setup wizard)
Click to expand MCP client config snippets #### macOS โ€” Claude Desktop Config file: `~/Library/Application Support/Claude/claude_desktop_config.json` ```json { "mcpServers": { "native-devtools": { "command": "/Applications/NativeDevtools.app/Contents/MacOS/native-devtools-mcp" } } } ``` #### Windows โ€” Claude Desktop Config file: `%APPDATA%\Claude\claude_desktop_config.json` #### Claude Code, Cursor, and other MCP clients ```json { "mcpServers": { "native-devtools": { "command": "npx", "args": ["-y", "native-devtools-mcp"] } } } ``` Requires Node.js 18+.
> **macOS permissions:** the server needs **Accessibility** and **Screen Recording** permissions. The setup wizard opens the right System Settings panes for you. Without both, clicks silently fail and screenshots return a black rectangle. > **Linux is not supported yet.** The server uses platform-specific APIs (Core Graphics + Accessibility on macOS, Win32 + UI Automation on Windows) that don't exist on Linux. Contributions welcome โ€” X11/Wayland screenshot, input, and AT-SPI paths would be a good first issue. ## ๐Ÿ Getting Started After installing, run the setup wizard: ```bash npx native-devtools-mcp setup ``` This will: 1. **Check permissions** (macOS) โ€” verifies Accessibility and Screen Recording, opens System Settings if needed. 2. **Detect your MCP clients** โ€” finds Claude Desktop, Claude Code, and Cursor. 3. **Write the configuration** โ€” generates the correct JSON config and offers to write it for you. Then restart your MCP client and you're ready to go. > **Claude Desktop on macOS** requires the signed app bundle (Gatekeeper blocks npx). Download `NativeDevtools-X.X.X.dmg` from [GitHub Releases](https://github.com/sh3ll3x3c/native-devtools-mcp/releases), drag to `/Applications`, then run setup โ€” it will detect the app and configure Claude Desktop to use it. > **VS Code, Windsurf, and other clients:** `setup` doesn't auto-detect these yet. Run `setup` for the permission checks, then see the manual configuration above for the JSON config snippet. > **Claude Code tip:** To avoid approving every tool call (clicks, screenshots), add this to `.claude/settings.local.json`: > ```json > { "permissions": { "allow": ["mcp__native-devtools__*"] } } > ``` ### โš ๏ธ Operational safety - **Hands off:** when the agent is "driving" (clicking / typing), don't move your mouse or type. Real hardware inputs conflict with simulated ones and clicks land in the wrong place. - **Focus matters:** ensure the window you want the agent to use is visible. If a popup steals focus mid-flow, the agent may type into the wrong window unless it re-checks first. - **Prefer AX Dispatch on macOS** when you want to keep using the machine โ€” AX calls don't move the cursor and don't steal focus from whatever window is active. ## ๐Ÿ“š Recipes and Examples - [Recipes Index](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/README.md) - [Claude Desktop Setup](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/claude-desktop-setup.md) ยท [Claude Code Setup](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/claude-code-setup.md) ยท [Cursor Setup](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/cursor-setup.md) - [End-to-End Desktop Flow](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/end-to-end-desktop-flow.md) - [Native App AX Dispatch Flow (macOS)](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/native-app-ax-dispatch-flow.md) โ€” **preferred for native macOS apps** - [Native App Click Flow](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/native-app-click-flow.md) - [OCR Fallback and Element Inspection](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/ocr-fallback-and-element-inspection.md) - [Template Matching Flow](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/template-matching-flow.md) - [Android Quickstart](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/examples/android-quickstart.md) ## ๐ŸŒ Browser Automation (CDP) Connect to Chrome or Electron apps via the Chrome DevTools Protocol for DOM-level automation โ€” more reliable than coordinate-based clicking for web content. ```bash # Launch Chrome with remote debugging launch_app(app_name="Google Chrome", args=["--remote-debugging-port=9222", "--user-data-dir=/tmp/chrome-profile"]) # Connect and automate cdp_connect(port=9222) cdp_navigate(url="https://example.com") cdp_find_elements(query="search") # DOM walker with element UIDs (d1, d2, ...) cdp_fill(uid="d1", value="search query") cdp_press_key(key="Enter") cdp_wait_for(text=["Results"]) ``` **18 CDP tools** โ€” DOM snapshot, find elements, click, hover, fill, type, press key, navigate, handle dialogs, manage tabs, evaluate JS, element inspection, and more. Works with Chrome 136+, Chromium, and Electron apps (Signal, Discord, VS Code, Slack). See [`AGENTS.md`](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/AGENTS.md) for the full tool reference. > **Chrome 136+ note:** requires `--user-data-dir=` alongside `--remote-debugging-port` โ€” Chrome silently ignores the debug port with the default profile. Electron apps only need `--remote-debugging-port`. ## ๐Ÿ“ฑ Android Support Android support is built-in. The server communicates with Android devices over ADB (USB or Wi-Fi), providing screenshots, input simulation, UI element search, and app management. ### Prerequisites 1. **ADB installed** on the host (`brew install android-platform-tools` on macOS, or via [Android SDK](https://developer.android.com/tools/releases/platform-tools)). 2. **USB debugging enabled** on the device (Settings > Developer options > USB debugging). 3. **ADB server running** โ€” starts automatically when you run `adb devices`. ### Tools All Android tools are prefixed with `android_` and appear dynamically after connecting to a device: | Tool | Description | |------|-------------| | `android_list_devices` | List all ADB-connected devices (always available) | | `android_connect` | Connect to a device by serial number | | `android_disconnect` | Disconnect from the current device | | `android_screenshot` | Capture the device screen | | `android_find_text` | Find UI elements by text (via uiautomator) | | `android_click` | Tap at screen coordinates | | `android_swipe` | Swipe between two points | | `android_type_text` | Type text on the device | | `android_press_key` | Press a key (e.g., `KEYCODE_HOME`, `KEYCODE_BACK`) | | `android_launch_app` | Launch an app by package name | | `android_list_apps` | List installed packages | | `android_get_display_info` | Get screen resolution and density | | `android_get_current_activity` | Get the current foreground activity | ### Typical workflow ``` android_list_devices โ†’ find your device serial android_connect(serial="...") โ†’ connect (unlocks android_* tools) android_screenshot โ†’ see what's on screen android_find_text(text="OK") โ†’ locate a button android_click(x=..., y=...) โ†’ tap it ```
Known issues & advanced setup **MIUI / HyperOS (Xiaomi, Redmi, POCO devices):** input injection (`android_click`, `android_type_text`, `android_press_key`, `android_swipe`) and `android_find_text` (via uiautomator) require an additional security toggle: > **Settings > Developer options > USB debugging (Security settings)** โ€” enable this toggle. MIUI may require you to sign in with a Mi account to enable it. Without this, you'll see `INJECT_EVENTS permission` errors for input tools and `could not get idle state` errors for `android_find_text`. Screenshot and device info tools work without this toggle. **Wireless ADB:** to connect without a USB cable, first connect via USB and run: ```bash adb tcpip 5555 adb connect :5555 ``` Then use the `:5555` serial in `android_connect`. **Smoke tests:** verify all Android tools against a real connected device. They are `#[ignore]`d by default: ```bash cargo test --test android_smoke_tests -- --ignored --test-threads=1 ``` Tests must run sequentially since they share a single physical device. The device must be unlocked and awake.
## ๐Ÿ” Security & Trust This tool requires Accessibility and Screen Recording permissions โ€” that's a lot of trust. Here's how to verify it deserves it. ### Verify your binary ```bash native-devtools-mcp verify ``` Computes the SHA-256 hash of the running binary and checks it against the official checksums published on the [GitHub Releases](https://github.com/sh3ll3x3c/native-devtools-mcp/releases) page. If the hash matches, you're running an unmodified official build. ### Audit the code [`SECURITY_AUDIT.md`](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/SECURITY_AUDIT.md) documents exactly which permissions are used, where in the source code, and includes an LLM audit prompt you can paste into any AI model for an independent security review. ### What this server does NOT do - **No unsolicited network access.** The server never phones home. Network is only used when the MCP client explicitly invokes `app_connect` (WebSocket to a local debug server) or when you run the `verify` subcommand (fetches checksums from GitHub). - **No file scanning.** Does not read or index your files. The only file reads are `load_image` (a path the MCP client explicitly provides) and short-lived temp files for screenshots (deleted immediately after capture). - **No background persistence.** Exits when the MCP client disconnects. - **No data exfiltration.** Screenshots are returned to the MCP client via stdout, never stored or transmitted elsewhere. ## โ“ FAQ **Does it work on Linux?** Not yet โ€” macOS, Windows, and Android only. The server uses Core Graphics + Accessibility APIs on macOS and Win32 + UI Automation on Windows. An X11/Wayland + AT-SPI port would be a welcome contribution. **Does it need an API key?** No. The server runs entirely locally and makes no outbound API calls. Your MCP client may need its own LLM API key (Anthropic, OpenAI, etc.), but the server itself does not. **How is this different from Claude Computer Use?** Claude Computer Use is an [Anthropic API beta tool](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) โ€” it works with Claude Opus, Sonnet, and Haiku behind a beta header and requires an Anthropic API key. It operates via screenshots + coordinate-based mouse/keyboard actions. `native-devtools-mcp` is model-agnostic (anything that speaks MCP), runs 100% locally with no API dependency, and adds element-precise macOS AX dispatch, Chrome DevTools Protocol, and Android over ADB. **Does it work with local models (Ollama, LM Studio, etc.)?** Yes โ€” as long as the client speaks MCP. Any MCP-compatible client can connect. Non-MCP clients can wrap the server behind a bridge. **Is it free / open source?** Yes, MIT-licensed. See [`LICENSE`](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/LICENSE). **Does it record what I'm doing?** No โ€” unless you explicitly call `start_recording`, which writes to a directory you specify and stops on `stop_recording`. Hover tracking likewise runs only while `start_hover_tracking` is active. Nothing is recorded or sent anywhere otherwise. **How does it compare to Playwright or [Playwright MCP](https://github.com/microsoft/playwright-mcp)?** Playwright is the mature choice for pure web automation โ€” Chromium, Firefox, and WebKit, plus first-class Electron support via `_electron.launch()` and experimental Android automation. Playwright MCP wraps it as an MCP server for AI agents. If you only need web / Electron automation, use Playwright MCP. `native-devtools-mcp` covers native macOS / Windows apps and Android devices in addition to Chrome/Electron, in one local MCP server โ€” which Playwright MCP does not. ## ๐Ÿ—๏ธ Architecture ```mermaid graph TD Client[Claude / LLM Client] <-->|JSON-RPC 2.0| Server[native-devtools-mcp] Server -->|Direct API| Sys[System APIs] Server -->|CDP / WebSocket| Chrome[Chrome / Electron] Server -->|WebSocket| Debug[AppDebugKit] Server -->|ADB Protocol| Android[Android Device] subgraph "Your Machine" Sys -->|Screen/OCR| macOS[CoreGraphics / Vision] Sys -->|Input| Win[Win32 / SendInput] Sys -->|Text Search| UIA[UI Automation] Sys -->|AX Snapshot + Dispatch| AXapi[Accessibility API - macOS] Chrome -.->|DOM-level| ChromeApp[Web Page / Electron UI] Debug -.->|Inspect| App[Instrumented App] end subgraph "Android Device (USB/Wi-Fi)" Android -->|screencap| Screen[Screenshots] Android -->|input| Input[Tap / Swipe / Type] Android -->|uiautomator| UITree[UI Hierarchy] end ```
๐Ÿ”ง Technical Details (Under the Hood) | OS | Feature | API Used | |----|---------|----------| | **macOS** | Screenshots | `screencapture` (CLI) | | | Input | `CGEvent` (CoreGraphics) | | | Text Search (`find_text`) | `Accessibility API` (primary), Vision OCR (fallback) | | | AX Snapshot + Dispatch (`take_ax_snapshot` / `ax_click` / `ax_set_value` / `ax_select`) | Accessibility API โ€” AX tree walk, `AXPress` action, `kAXValueAttribute` write, `AXSelectedRows` write (focus-preserving, no mouse movement) | | | Element Inspection (`element_at_point`) | `AXUIElementCopyElementAtPosition` + AX tree walk fallback | | | Hover Tracking (`start_hover_tracking`) | `CGEvent` cursor + Accessibility API polling | | | Screen Recording (`start_recording`) | `CGWindowListCreateImage` at configurable fps | | | OCR | `VNRecognizeTextRequest` (Vision Framework) | | **Windows** | Screenshots | `BitBlt` (GDI) | | | Input | `SendInput` (Win32) | | | Text Search (`find_text`) | `UI Automation` (primary), WinRT OCR (fallback) | | | Element Inspection (`element_at_point`) | `IUIAutomation::ElementFromPoint` | | | Hover Tracking (`start_hover_tracking`) | `GetCursorPos` + UI Automation polling | | | Screen Recording (`start_recording`) | `BitBlt` (GDI) at configurable fps | | | OCR | `Windows.Media.Ocr` (WinRT) | | **Android** | Screenshots | `screencap` / ADB framebuffer | | | Input | `adb shell input` (tap, swipe, text, keyevent) | | | Text Search (`find_text`) | `uiautomator dump` (accessibility tree) | | | Device Communication | `adb_client` crate (native Rust ADB protocol) | | **Chrome / Electron** | DOM-level automation | Chrome DevTools Protocol via `chromiumoxide` | ### Screenshot Coordinate Precision Screenshots include metadata for accurate coordinate conversion: - `screenshot_origin_x/y`: Screen-space origin of the captured area (in points) - `screenshot_scale`: Display scale factor (e.g., 2.0 for Retina displays) - `screenshot_pixel_width/height`: Actual pixel dimensions of the image - `screenshot_window_id`: Window ID (for window captures) **Coordinate conversion:** ``` screen_x = screenshot_origin_x + (pixel_x / screenshot_scale) screen_y = screenshot_origin_y + (pixel_y / screenshot_scale) ``` **Implementation notes:** - **Window captures** (macOS): uses `screencapture -o` which excludes window shadow. Captured dimensions match `kCGWindowBounds ร— scale` exactly, so click coordinates derived from screenshots land on intended UI elements. - **Region captures:** origin coordinates are aligned to integers to match the actual captured area.
## ๐ŸชŸ Windows Notes Works out of the box on **Windows 10/11**. - Uses standard Win32 APIs (GDI, SendInput). - `find_text` uses **UI Automation (UIA)** as the primary search mechanism, querying the accessibility tree for element names. This is the same accessibility-first approach used on macOS. Falls back to OCR automatically when UIA finds no matches. - OCR uses the built-in Windows Media OCR engine (offline). - **Cannot interact with "Run as Administrator" windows** unless the MCP server itself is also running as Administrator. - **Screen recording** uses GDI/BitBlt at configurable fps (default 5). For higher fps or game capture, DXGI Desktop Duplication API would provide hardware-accelerated capture โ€” a planned future upgrade. ## ๐Ÿค– For AI Agents Agent-oriented usage โ€” intent definitions, schema examples, reasoning patterns โ€” lives in [**`AGENTS.md`**](https://github.com/sh3ll3x3c/native-devtools-mcp/blob/HEAD/AGENTS.md). It's a compact, token-optimized reference designed for ingestion by LLMs (Claude, Gemini, GPT, local models). If you're an AI agent reading this README to decide whether to use the server, go there next. ## โญ Star History Star History Chart ## ๐Ÿ“œ License MIT ยฉ [sh3ll3x3c](https://github.com/sh3ll3x3c)