Skip to main content
Glama

Jev MCP

中文说明

jev-mcp turns browser-use/jev-ultrafast into one local, session-aware MCP server for fast read-only product research. Jev selects an action and observed target from a DOM snapshot; this wrapper gives an MCP host the tools and lifecycle it needs to use that loop safely.

What it is (and is not)

This is one local stdio MCP server, not a replacement browser extension and not four separate MCPs. It owns browser targets created by Jev and exposes five model-facing tools:

Tool

Use it for

Does not do

jev_browse

Start a public-site search, filtering, or product-detail task

Log in, checkout, pay, upload, or submit an order

jev_status

Read a session's URL, visible text, supported controls, and latest actions

Take another browser action

jev_extract_products

Read visible product card fields: name, price, rating, details, URL

Scroll, click, or guarantee site-specific parsing

jev_stop

Close the Jev-owned Chrome target

Affect ordinary user Chrome tabs

jev_decide

Relay mode: judge host-supplied page state and return the next operation + target element, no browser

Open a browser, session, or tab; take any page action

Relay mode: if you only want Jev as an intermediate decision relay — your own browser tooling (e.g. opencli, computer-use) drives the page and you pass the observed elements in — use jev_decide ONLY. It never opens a browser, session, or tab, so no new pages are created.

The upstream Jev agent remains an isolated Git dependency pinned to commit 1231850a0bf1a0c0341fe408ef1668dbbfdfac46; this repository contains the MCP session layer, output shaping, product extraction, and safety guardrails. This keeps upgrades reviewable and avoids carrying a modified upstream fork.

Related MCP server: web-scraper-server

Requirements

  • Python 3.12+

  • uv

  • A Chrome/Chromium installation supported by browser-harness

  • An OPENROUTER_API_KEY for Jev Decisions (recommended), or a direct TYPESAFE_API_KEY

  • TEXT_MODEL_API_KEY for search/filter text entry; the default example uses OpenRouter

Setup

git clone https://github.com/wahahaorg/jev-mcp.git
cd jev-mcp
cp .env.example .env
# Put real keys in .env; never commit it. OpenRouter Decisions is the default path.
uv sync
uv run browser-harness --doctor

browser-harness may ask Chrome for remote-debugging permission. The server creates its own background Chrome target; it does not take over the currently visible tab.

Run it locally:

uv run --env-file .env jev-mcp

The server uses stdio: stdout is reserved for MCP JSON-RPC. It waits for an MCP host rather than opening a web page itself.

MCP configuration

Copy the mcpServers.jev-browser object in .mcp.json into your MCP host configuration. Replace the command's directory with this repository's absolute path if the host does not start processes from the repository root.

Example:

{
  "mcpServers": {
    "jev-browser": {
      "command": "uv",
      "args": ["run", "--directory", "/absolute/path/to/jev-mcp", "--env-file", ".env", "jev-mcp"]
    }
  }
}

Keep credentials in the host environment or .env; never place keys in the configuration committed to source control. The included configuration assumes the host starts it from this repository; use the absolute-path version above otherwise.

Typical flow

  1. Call jev_browse with a public URL and a narrow goal, for example: “Search wireless headphones, set the price filter below $100, and stop when results are visible.”

  2. Keep the returned session_id.

  3. Call jev_status when you need to decide whether the page is ready or why it blocked.

  4. Call jev_extract_products on a visible result/detail page.

  5. Call jev_stop when finished.

When OPENROUTER_API_KEY is present, the wrapper sends Jev decisions to OpenRouter's alpha Decisions endpoint using ~typesafe/jev-latest; otherwise it retains the upstream direct TypeSafe client. The agent is deliberately bounded to 30 browser actions per jev_browse call and upstream Jev itself has a 60-action run cap. Results are observations, not proof of stock, availability, or final checkout price.

Safety model

The wrapper rejects transactional goals before a browser opens and blocks observed add-to-cart, purchase, checkout, payment, upload, credential, card, and verification-code controls just before execution. It also refuses password/file controls inherited from upstream's DOM snapshot safeguards. This is a browsing and extraction integration, not a purchasing bot.

Web content is treated as untrusted data. Product extraction is best-effort and returns only currently visible cards; validate important prices, variants, and shipping details on the source page.

Development and verification

uv run ruff check .
uv run pytest
npx @modelcontextprotocol/inspector uv run --env-file .env jev-mcp

The test suite uses a fake browser/agent, so it does not spend API credits or require Chrome. evals.xml contains ten multi-tool evaluation scenarios, including error recovery and safety boundaries. Use the Inspector with real credentials to validate the MCP framing and a public browsing task.

License

MIT. The upstream Jev dependency is also MIT-licensed; see its repository for its terms and notices.

Available Tools

4 tools
jev_browseA

Start a new browser session and advance a read-only browsing goal.

Use this for finding, filtering, or opening products on a public website. It executes at most max_steps (1–30) before returning a session_id, visible page evidence, and recent actions. Do not use it for login, checkout, payment, uploads, or any task that enters personal or financial data.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYes
goalYes
max_stepsNo

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does a good job: it discloses read-only behavior, the max_steps cap, and the return contents (session_id, visible page evidence, recent actions). It also warns against personal/financial data entry. It does not mention side effects like server-side state, cookies, or rate limits, but it covers the most critical safety and operational traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short paragraphs with no filler. The core purpose and primary constraint are front-loaded, and every sentence provides actionable information: what it does, when to use, how executions are bounded, what is returned, and what to avoid.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given three parameters, no annotations, and no output schema, the description covers the essential invocation context: URL, goal, max_steps, return values, and usage boundaries. It lacks a precise definition of 'visible page evidence' or 'advance,' and does not explain how to handle already-open sessions, but the provided information is sufficient for a competent agent to invoke the tool correctly in most cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description must compensate. It adds meaningful context for max_steps by giving a range (1–30) and explaining its role, and it implies goal is a browsing objective like 'finding, filtering, or opening products.' However, url is not explicitly described beyond the phrase 'public website,' and the two required parameters are not fully disambiguated, so the compensation is partial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('Start a new browser session') plus the goal ('advance a read-only browsing goal'). It clearly differentiates itself from siblings like jev_status and jev_stop by emphasizing session creation and read-only browsing, and from jev_extract_products by focusing on browsing rather than extraction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit use cases ('finding, filtering, or opening products') and strong exclusions ('Do not use it for login, checkout, payment...'), which is more than a minimal viable. However, it does not name any alternative sibling tools or specify when to prefer them, so it stops short of the full when/when-not/alternatives guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jev_extract_productsA

Extract product name, price, rating, details, and link from currently visible product cards.

Use this after jev_browse reaches a results or product page. This is best-effort read-only DOM extraction; it does not scroll, click, or infer fields that are not visible, so verify important price or stock data.

ParametersJSON Schema
NameRequiredDescriptionDefault
session_idYes

TDQS

A4.3/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description takes on full responsibility for disclosing side effects and limitations. It states it's read-only, best-effort, does not scroll/click/infer, and warns to verify important price/stock data. This is robust behavioral transparency for a DOM extraction tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences in the first paragraph plus three clauses in the second, front-loaded with the core action and followed by precondition and caveats. No filler; every clause contributes.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with no output schema, the description covers what is extracted, when to call it, and its limitations. It stops short of describing the exact return structure or behavior when no cards are visible, but the listed fields and caveats make it reasonably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has one required string parameter (session_id) and schema description coverage is 0%. The description never mentions session_id, its format, or its purpose, so it adds no meaning beyond the field name. For a tool with low schema coverage, this is a clear gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Extract'), a specific resource ('product name, price, rating, details, and link from currently visible product cards'), and scopes it to visible product cards, which separates it from the sibling tools (browse/status/stop). It is clearly not a navigation or status tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly tells the agent to use this after jev_browse reaches a results or product page, and clarifies that it is best-effort read-only and does not scroll, click, or infer. This gives a clear precondition and implies when it is not suitable (when interaction or scrolling is needed), though it doesn't name an alternative tool explicitly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jev_statusA

Inspect a live Jev browser session without taking another browser action.

Use it after jev_browse to reason from the current URL, visible text, supported controls, and recent actions. It does not load a page, click a control, scroll, or generate model requests.

ParametersJSON Schema
NameRequiredDescriptionDefault
session_idYes

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the tool does not load a page, click, scroll, or generate model requests, effectively declaring its read-only and non-interactive nature. It also notes it inspects a 'live' session, implying current state. While it doesn't cover error handling or output structure, the key behavioral traits are transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences with no filler. The first sentence states the core function, the second provides usage context, and the third clarifies exclusions. Every sentence earns its place and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with no output schema, the description is nearly complete. It tells the agent what the tool does, when to use it, what it does not do, and what information can be reasoned about (URL, text, controls, recent actions). The only minor gap is the lack of explicit output format or structure, but the absence of an output schema lowers that expectation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides zero description coverage for session_id, so the description must compensate. It does by referring to a 'live Jev browser session' and instructing to 'Use it after jev_browse,' which implies session_id is the identifier returned by that preceding call. This contextualizes the parameter even though the description does not explicitly define its format or origin.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource ('Inspect a live Jev browser session') and immediately distinguishes it from action-taking tools by adding 'without taking another browser action.' It also explicitly names jev_browse as the preceding tool, making it clear this is a passive observation tool, not an action tool. This is unambiguous and differentiates from siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives a clear 'when to use' instruction: 'Use it after jev_browse to reason from the current URL, visible text, supported controls, and recent actions.' It also provides 'when not' by stating it does not load, click, scroll, or generate model requests. However, it does not explicitly name alternatives like jev_stop or jev_extract_products, so it falls just short of a perfect 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

jev_stopA

Close one Jev-owned Chrome target and remove its session.

Call this when product research is complete or after an unrecoverable block. The session_id becomes invalid immediately; this never affects tabs outside the Jev-owned browser target.

ParametersJSON Schema
NameRequiredDescriptionDefault
session_idYes

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that the session_id becomes invalid immediately and that the operation is scoped to the Jev-owned target, which is valuable mutating-effect context. It could go further by noting what happens to all tabs within that target, but the phrase 'close one Jev-owned Chrome target' strongly implies that scope.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two tight sentences: the first states the core action, the second gives usage context and a key side-effect guarantee. There is no fluff, and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a simple single-parameter cleanup tool with no output schema and no annotations. The description covers what the tool does, when to call it, and the most important behavioral consequence. The only notable gap is that it assumes the agent already knows where session_id comes from, but the sibling tools and parameter name make that reasonably inferable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description provides little meaning for session_id beyond 'becomes invalid immediately.' It does not explain that the session_id must correspond to a previously opened Jev-owned target, how to obtain it, or what formats or constraints apply. The name is self-explanatory, but the description adds almost no parameter guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Close'), names the resource ('one Jev-owned Chrome target'), and states the secondary action ('remove its session'). This clearly distinguishes it from sibling tools like jev_browse, jev_status, and jev_extract_products, which cover navigation, status checks, and extraction rather than cleanup.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to call the tool: 'when product research is complete or after an unrecoverable block.' It also clarifies a non-effect ('never affects tabs outside the Jev-owned browser target'), which helps an agent reason about side effectsz. However, it does not explicitly name alternatives or state when not to call it, so it stops short of full exclusion guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 4 tool updatesv0.1.0
    • First observedjev_browse
    • First observedjev_extract_products
    • First observedjev_status
    • First observedjev_stop

TDQS

A4.4/5.0

Scored across 4 tools

Disambiguation5/5

Each tool has a clearly distinct role: browse starts/advances sessions, status inspects without acting, extract parses visible product cards, and stop closes the session. There is no functional overlap or ambiguity between them.

Naming Consistency4/5

All tools share the 'jev_' prefix and are short, readable command-style names. 'jev_status' is a noun rather than a verb like the others, but this is a minor deviation that does not harm predictability.

Tool Count5/5

Four tools are well-scoped for a read-only browser automation server focused on product research. Each tool serves a distinct stage in the session lifecycle with no redundancy.

Completeness5/5

The tool set covers the full workflow: start/advance browsing, inspect session state, extract product data, and close the session. There are no obvious dead ends or missing lifecycle operations for the stated purpose.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    C
    quality
    D
    maintenance
    A session-based MCP server that provides advanced browser automation capabilities, allowing users to control browsers, navigate websites, interact with elements, capture screenshots, generate PDFs, and manage cookies through natural language.
    35
    1
    MIT
  • A
    license
    C
    quality
    C
    maintenance
    Provides browser automation and web scraping as MCP tools, enabling autonomous URL ingestion, crawling, extraction, and anti-bot handling with interactive browser control.
    62
    5
    MIT
  • A
    license
    A
    quality
    B
    maintenance
    Browser-based research MCP server that drives a real Chromium browser via patched Playwright to access JavaScript-rendered content, dynamic tables, and login-walled dashboards. It provides tools for visiting URLs to extract DOM text and screenshots, and for performing structured data extraction using Anthropic Claude Sonnet.
    3
    Apache 2.0
  • A
    license
    Not graded
    quality
    A
    maintenance
    MCP server for local browser control via Chrome/Edge extension, enabling agents to open isolated tabs, observe pages, take screenshots, and interact with accessible controls using an existing browser profile. It is agent-agnostic, local-only, and supports safe session scoping with origin grants and sensitive-data blocking.
    MIT