Allows AI agents to see and interact with Electron/Chromium windows via OCR fallback when accessibility tree is unavailable.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@vision-bridge capture the foreground window"
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.
One vision layer for AI agents on Windows — a single MCP server that lets any agent see and act on the screen: native desktop apps, Electron/Chromium windows, and the browser — undetected.
Most agent setups end up with a pile of disconnected tools: one for the browser,
one for native windows, one for OCR, each with its own quirks. vision-bridge
hides all of that behind four verbs — capture, act, find, wait_for —
so the agent asks "what's on screen?" and "click this" the same way
everywhere. The router picks the right backend underneath.
It is designed for text-only brains too (e.g. DeepSeek, local LLMs): the screen is returned as structured text, not pixels, so an agent that can't consume images can still understand and drive the UI.
🖥️ Desktop — native Win32/WPF/UWP via UI Automation (fast, exact, coordinate-free clicks).
🧩 Electron/Chromium — OCR fallback when the a11y tree is blind.
🌐 Browser, undetected — drive your real Chrome over CDP (live cookies,
sessions never drop) or a stealth browser (patchright, persistent profile,
navigator.webdriver = false).
🔌 Standard MCP — stdio transport, works with Claude Desktop, Cline, Cursor, or any custom agent, no code changes.
Deep-dive design & rationale (RU):
docs/01_architecture.md
An agent that "sees the screen" usually means gluing Playwright + some UIA library
Tesseract together and teaching the model three different mental models. This project makes that one contract. Add a backend, keep the same four tools. The agent never learns "how" — only "what".
Related MCP server: EZComputerCtrl MCP
If you are an LLM agent reading this to use the server: call capture(target) to
get a list of Elements (each with a stable id) plus a flat text dump of the
screen. Then call act(element_id, action, ...). You never compute coordinates or
CSS selectors — you address elements by the id from the last capture/find.
id prefixes tell you the backend (u=desktop, o=OCR, b=browser); the server
routes automatically.
Tool | Purpose |
| Screen of a target → |
|
|
| Locate one element by name/value |
| Poll until an element appears |
| Connect/launch a browser |
| Navigate the open browser |
| Close the browser session |
target: a window title substring for desktop, or "browser" for the page.
Empty target = foreground window. mode: auto | uia | ocr | browser.
Element{
"id": "u17", // stable ref; prefix = backend (u/o/b)
"role": "button", // button | textbox | link | text | ...
"name": "OK",
"value": null,
"bbox": [120, 80, 60, 24], // screen coords [x, y, w, h]
"state": { "enabled": true, "focused": false, "visible": true, "checked": null },
"backend": "uia"
}uv sync # core: MCP + pydantic
uv sync --extra desktop # UIA + OCR (uiautomation, pytesseract, mss)
uv sync --extra browser # stealth/CDP browser (patchright)OCR needs the Tesseract-OCR binary (not the pip package): install it (e.g.
winget install UB-Mannheim.TesseractOCR). For extra languages, pull the models
into a local tessdata/ folder (no admin rights needed — picked up automatically):
uv run python scripts/download_langs.py # Russian + English (default)
uv run python scripts/download_langs.py deu fra # any Tesseract languagesRussian is supported out of the box via the script above (rus+eng). The backend
finds tessdata/ next to the project or via VISION_BRIDGE_TESSDATA.
uv run vision-bridge # stdio server
uv run mcp dev src/vision_bridge/server.py # MCP InspectorAny MCP client with a command/args config:
{
"servers": {
"vision-bridge": {
"command": "uv",
"args": ["run", "--directory", "/path/to/vision-bridge", "vision-bridge"]
}
}
}Desktop:
capture("Notepad") # → elements + text of the window
act("u0", "type", text="hello world") # type into the document
act("u0", "read") # → { content: "hello world" }Browser, undetected — real Chrome (max stealth, keeps your sessions):
# start Chrome with a debug port and your profile first:
chrome.exe --remote-debugging-port=9222 --user-data-dir="C:\path\profile"browser_open(mode="cdp", cdp_url="http://localhost:9222")
capture("browser")
act("b3", "type", text="search query")Browser — standalone stealth profile:
browser_open(mode="stealth", url="https://example.com",
user_data_dir="C:\\path\\profile") # navigator.webdriver = false capture(target, mode="auto")
│
target=="browser" ───┼─── desktop window ───────────────┐
│ │ │
┌────▼────┐ UI Automation a11y tree (few elements? →)
│ browser │ ┌──────────────┐ ┌──────────────┐
│ cdp / │ │ UIA │ ── fallback ──▶ │ OCR (Tess.) │
│ stealth │ └──────────────┘ └──────────────┘
└─────────┘Stages 0–3 implemented and tested live on real apps (Notepad, Chrome). Roadmap: agent skill + scenario tests, optional OmniParser for clickable boxes instead of plain OCR text.
Stealth is not 100% undetectable (Cloudflare/DataDome evolve) — prefer
mode="cdp" against real Chrome for maximum stealth and session persistence.
Console output with non-ASCII: run under PYTHONUTF8=1 (does not affect the
UTF-8 MCP protocol).
MIT — see LICENSE.
Единый слой зрения для AI-агентов на Windows как один MCP-сервер. Четыре
глагола — capture, act, find, wait_for — работают одинаково для нативных
окон, Electron/Chromium (через OCR) и браузера. Экран отдаётся текстом, поэтому
подходит даже текстовым моделям (DeepSeek и др.). Браузер — незаметно: реальный
Chrome по CDP (живые куки, сессии не рвутся) или стелс-браузер на patchright
(navigator.webdriver=false). OCR понимает русский (uv run python scripts/download_langs.py). Архитектура и план — в
docs/01_architecture.md.
Выполнить действие над элементом из capture()/find().
action: click | double_click | type | set_value | focus | read | scroll.
text: для action="type" — что напечатать.
value: для action="set_value" — новое значение поля (заменяет целиком).
Для action="read" текст возвращается в поле content.
Бэкенд выбирается по префиксу element_id (u=десктоп, o=OCR, b=браузер).
| Name | Required | Description | Default |
|---|---|---|---|
| text | No | ||
| value | No | ||
| action | Yes | ||
| element_id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It mentions that for action='read' the text is returned in 'content' and that backend is selected based on element_id prefix, but fails to disclose side effects, synchronization, or error behavior for mutating actions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, listing actions and parameters without unnecessary text. It front-loads the purpose and is well-organized, though a bit terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so description should address returns. It does for read, but not for other actions. Missing details on prerequisites (element from capture/find) and error handling. Adequate but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It explains 'text' for type, 'value' for set_value, and 'content' for read, but does not elaborate on 'element_id' or 'action' beyond listing options. Partial improvement over bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs an action on an element from capture()/find(), listing specific actions. This distinguishes it from sibling tools like capture/find (element retrieval) and browser_goto (navigation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description details the available actions and their parameters, but does not explicitly state when to use this tool versus alternatives or provide exclusions. The context is implied but not formal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Закрыть браузерную сессию слоя.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist. The description states it closes a session but does not explain side effects, idempotency, or what happens to ongoing actions. Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (one phrase) but front-loaded with the action. However, it could benefit from more structure or context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters or output schema, the description is functional but lacks context about how the layer concept works and interaction with other tools. Sufficient for a simple close action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so the schema covers everything. Baseline 4 applies since no additional parameter info is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool closes a browser session, which is a specific resource action. It distinguishes from siblings like browser_open and browser_goto, though the term 'layer' is ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 or when to use alternatives. There is no mention of prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Перейти по URL в открытом браузере.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior, but it only states the action. It does not mention whether the navigation replaces the current page or opens a new tab, whether it waits for page load, or what the return value is.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. However, it could be restructured to front-load the action and include key constraints without increasing length significantly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema and low schema coverage, the description provides insufficient context. The agent needs to know what happens after navigation (e.g., returns page content, status) and possible error conditions, which are absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage for the 'url' parameter, and the tool description adds no meaning beyond the type 'string'. It fails to specify URL format, required protocol, or handling of relative URLs, leaving the agent guessing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifically states the action ('go to') and the resource ('URL in an open browser'). It clearly distinguishes from siblings like browser_open (which opens a browser) and browser_close (which closes), making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, such as prerequisites (browser must already be open) or when to prefer other navigation methods. The description only states what it does, not when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Открыть/подключить браузер для незаметной работы.
mode="cdp": подключиться к УЖЕ запущенному Chrome по DevTools-протоколу
(cdp_url, по умолчанию http://localhost:9222). Максимальная незаметность,
живые куки, сессии не рвутся. Chrome нужно стартовать заранее с
--remote-debugging-port=9222 и своим --user-data-dir.
mode="stealth": свой браузер под управлением слоя (patchright) с постоянным
профилем user_data_dir и каналом реального Chrome (channel="chrome").
url: если задан — сразу перейти. После открытия используй capture("browser").
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | ||
| mode | No | stealth | |
| cdp_url | No | ||
| channel | No | chrome | |
| headless | No | ||
| user_data_dir | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description discloses behavioral traits: stealthy operation, prerequisites for cdp mode, and that it connects or opens a browser. It could mention effects like reconnecting if already open.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with line breaks and bullet points, though slightly verbose. Every sentence adds value, but it could be more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (two modes, 6 parameters) and no output schema, the description covers most modes and parameters but omits headless and does not specify return value or prerequisites beyond cdp mode. Suggests using capture, which helps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% parameter description coverage, but the description explains url, mode, cdp_url, channel, and user_data_dir in context, adding meaning beyond the schema. The headless parameter is not mentioned.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Open/connect a browser for stealthy work' and distinguishes two modes (cdp and stealth), making it specific and differentiating from siblings like browser_close and browser_goto.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use each mode (cdp for maximum stealth and live sessions, stealth for own browser with persistent profile) and suggests using capture after opening, but does not explicitly state when not to use the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Посмотреть на цель и вернуть её как структуру + текст.
target: заголовок окна десктоп-приложения (подстрока, регистронезависимо), либо "browser" для активной страницы открытого браузера; пусто — активное окно на переднем плане. mode: "auto" (сам выбирает: UIA → при бедном результате OCR), либо принудительно "uia" | "ocr" | "browser".
Возвращает {ok, elements:[{id,role,name,bbox,...}], text, method_used}. Текстовый
мозг читает text, действует по elements[].id через act().
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | auto | |
| target | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden. It describes modes (auto/UIA/OCR/browser) and the return format, but does not mention side effects, safety (read-only), or behavior when target is not found. It offers moderate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively concise and includes structured details about parameters and return values. It is slightly verbose but well-organized, with no redundant sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return structure (ok, elements, text, method_used) and element properties (id, role, name, bbox). It provides enough context for an agent to invoke and interpret results, though it could mention error handling or limitations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description fully compensates by explaining 'target' as window title substring, 'browser' keyword, or empty string, and 'mode' with auto selection logic and forced options. This adds substantial meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool captures a target window or browser page and returns it as structured elements and text. It specifies the verb 'capture' effectively and distinguishes itself from sibling tools like 'act' or 'browser_*' by focusing on UI state capture.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains how to specify target and mode but does not explicitly state when to prefer this tool over siblings like 'find' or 'wait_for'. The usage context is implied but not directly clarified, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Найти один элемент по описанию (имя/значение содержит query).
target: окно, либо "browser" для страницы; пусто — активное окно. mode: "auto" | "uia" | "ocr" | "browser".
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | auto | |
| query | Yes | ||
| target | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavioral traits. It mentions finding one element but does not disclose behavior on not found, waiting, scrolling, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with a main sentence followed by bullet-point-like details. Every sentence adds value, though it could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters, no output schema, and no annotations, the description is incomplete. It does not cover return values, error handling, or usage context, which is insufficient for an interactive tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It explains 'target' and 'mode' with valid values, but lacks detailed syntax (e.g., exact window identifiers) and does not describe 'query' beyond its purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the action (find) and resource (element) with a clear condition (description contains query). It is precise but does not distinguish from sibling tools like 'capture' or 'act'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides valid values for 'target' and 'mode' but does not specify when to use this tool versus alternatives such as 'wait_for' or 'act'. No explicit when/when-not advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Дождаться появления/готовности элемента (поллинг до timeout_s секунд).
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | auto | |
| query | Yes | ||
| target | No | ||
| timeout_s | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions polling and timeout_s but fails to disclose timeout behavior (error vs. return), what 'ready' means, or whether it modifies state. Agent lacks critical behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, terse sentence. While it front-loads the purpose, it is in Russian (potential language barrier) and lacks any structured breakdown. It is concise but at the expense of informativeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters, no output schema, and moderate complexity, the description is severely incomplete. It omits return values, error behavior, default timeout semantics, and any detail on what constitutes 'readiness'. Agent cannot reliably invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%. The description adds no explanation for parameters like 'mode', 'query', or 'target'. It only implicitly references timeout_s. Agent has no semantic guidance on how to use the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool waits for element appearance/readiness using polling. While the verb and resource are specific, it does not explicitly differentiate from sibling tool 'find' which might also locate elements.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 like 'find' or 'act'. The description does not state when not to use it or any preconditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0actbrowser_closebrowser_gotobrowser_opencapturefindwait_forEach tool has a unique purpose: act performs actions on elements, capture retrieves the view, find locates elements, wait_for waits for conditions, and browser_* tools handle browser lifecycle. No overlap.
Tool names are verb-based, using either single words (act, capture, find) or compound with underscore (browser_close, browser_goto). The browser_ prefix is consistent, but mixing single and compound forms is a minor inconsistency.
Seven tools is ideal for a vision-based automation server, covering all essential operations without being overwhelming or sparse.
The tool set covers the full workflow: opening/closing browsers, navigation, capturing the UI, finding elements, interacting, and waiting. No obvious gaps for standard UI automation tasks.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
The Remote MCP server acts as a standardized bridge between LLM applications (like Claude, ChatGPT, and Cursor) and external services, enabling AI agents to access external tools and resources. Its primary capability is providing a centralized search tool to discover other MCP servers and their respective tools. Unlike local implementations, it runs remotely with OAuth authentication and permission controls for security.
Unified MCP Server is a remote MCP connector for AI agents and vertical AI products that provides access to 22,000+ authorized SaaS tools across 400+ integrations and 24 categories directly inside LLMs (Claude, GPT, Gemini, Cohere). Tools operate only on explicitly authorized customer connections, enabling agents to safely read and write against live third-party systems.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/rusnetru/vision-bridge'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
