# jev-ra [Health: Active]

**Category:** 📂 Browser Automation  
**Repository:** https://github.com/brnyxx/jev-ra  
**GitHub Stars:** 4  
**npm Downloads (last month):** 146  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/jev-ra

## Description
A fast browser-use layer for CLI coding agents: MCP server, CLI and Python API. This package is a launcher; it runs the Python tool through uv.

## Tools
Capabilities this server exposes over MCP:

- **browser_open** — Open a URL in the shared session and summarise the page.
- **browser_run** — Pursue a whole goal. Supply values for anything that must be typed. `resume` carries on a run that stopped with `needs_human`.
- **browser_search** — Search, read the best results in parallel tabs, rank them against the goal.
- **browser_act** — Take one decided step towards an instruction.
- **browser_observe** — List the observed controls and the visible text.
- **browser_extract** — Structured page data: `text`, `elements`, `links`, `tables`, `main`.
- **browser_click** — Click one observed element by its ref.
- **browser_type** — Type into one observed field.
- **browser_select** — Select an observed dropdown option.
- **browser_scroll** — Scroll one viewport step up or down.
- **browser_press** — Press Enter, Escape or Tab.
- **browser_wait** — Wait a moment and observe again.
- **browser_screenshot** — JPEG of the current viewport.
- **browser_close** — Close the session held by the server.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "jev-ra": {
    "command": "uvx",
    "args": ["jev-ra"],
    "env": {
      "OPENROUTER_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `OPENROUTER_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What jev-ra does

jev-ra exposes browser automation through MCP, a command-line interface and a Python package launcher. It drives Chrome through the Chrome DevTools Protocol and lets an MCP client delegate either a complete browser goal or one deliberate interaction at a time.

Goal-based workflows use `browser_run`, which accepts a goal, optional values for text that must be entered, a step limit and an optional resume identifier. The server can also open a URL, search the web, inspect the current page, extract structured content, or perform direct browser operations. A run may stop with `needs_human`; supplying its resume value continues that run.

The browser session is shared by the server. Responses include elapsed time, and responses involving a Jev decision also include decision and cost information. Only text supplied by the caller is typed into a page.

## How it works

An MCP client sends a goal or browser operation to jev-ra. For goal-oriented steps, TypeSafe Jev selects the operation and target element, while the calling agent supplies any text values, reads the resulting page state and continues the workflow. Chrome is controlled through CDP, and the server can escalate a step for human handling.

Observed controls receive references. `browser_observe` returns a `page_key`; passing that key to click, type or select operations helps reject references from an older page state as stale. The server keeps session state between relevant commands, so an opened page can be inspected and acted on later.

## Setup and configuration

The quickest setup uses `uvx`, which runs the Python package from PyPI without a separate installation step. Export `OPENROUTER_API_KEY`, then use `uvx jev-ra install claude` or `uvx jev-ra install codex` to register the MCP server with the selected coding agent. `uvx jev-ra mcp` runs the stdio server directly.

The npm package is a launcher rather than a separate implementation. `npx -y jev-ra install claude` or the equivalent Codex command finds or offers to install `uv`, then runs the matching Python package. A permanent installation can use `uv tool install jev-ra`.

The command-line interface includes `doctor` for checking the key, endpoint, Chrome and one live decision. A Docker image can be built from the repository with Chromium included. The CLI also supports an HTTP and SSE mode through `jev-ra serve`, with host, port and quota options.

Use `--profile NAME` to assign a separate Chrome user-data directory. This allows a login or other browser state to persist for later runs using that profile. Run data is stored under the XDG state directory, with commands for inspecting timing and rendering a stored trace.

## Tools and capabilities

MCP tools include:

- `browser_open` to open a URL and summarize the page.
- `browser_run` to pursue a complete goal and optionally resume it.
- `browser_search` to search, read selected results in parallel tabs and rank them against a goal.
- `browser_act` to take one instructed step.
- `browser_observe` and `browser_extract` to inspect visible controls, text and structured page data.
- `browser_click`, `browser_type`, `browser_select`, `browser_scroll`, `browser_press` and `browser_wait` for direct interaction.
- `browser_screenshot` to capture the current viewport as JPEG.
- `browser_close` to close the server-held session.

Extraction modes include text, elements, links, tables and main content. The CLI provides corresponding commands, along with `run`, `search`, `open`, `trace`, `profile`, `clean`, `install`, `doctor` and `mcp`.

## Limitations and notes

Chrome must be available locally or supplied through the provided container setup. The server requires an OpenRouter API key for its decision process. Browser references can become stale after the page changes, and a workflow may require human intervention before it can continue. Browser sessions and profiles should be managed carefully when they contain authenticated state.

_Full upstream README: https://allmcps.com/mcp/jev-ra/readme_