jev-mcp
This server provides a read-only, session-aware MCP interface for product research on public websites using Jev's browser agent.
jev_browse: start a browser session for a public URL and goal, up to 30 steps, then return session ID, evidence, and actions.jev_status: inspect a live session's URL, visible text, supported controls, and recent actions without acting.jev_extract_products: extract visible product cards (name, price, rating, details, URL) from a results or product page.jev_stop: close a Jev-owned Chrome target and invalidate the session; does not affect ordinary tabs.jev_decide: act as a relay-only decision maker using host-supplied page state; never opens a browser or takes page actions.
Click on "Deploy 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., "@jev-mcpSearch Amazon for running shoes under $80 and extract product details."
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.
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 |
| Start a public-site search, filtering, or product-detail task | Log in, checkout, pay, upload, or submit an order |
| Read a session's URL, visible text, supported controls, and latest actions | Take another browser action |
| Read visible product card fields: name, price, rating, details, URL | Scroll, click, or guarantee site-specific parsing |
| Close the Jev-owned Chrome target | Affect ordinary user Chrome tabs |
| 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+
A Chrome/Chromium installation supported by
browser-harnessAn
OPENROUTER_API_KEYfor Jev Decisions (recommended), or a directTYPESAFE_API_KEYTEXT_MODEL_API_KEYfor 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 --doctorbrowser-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-mcpThe 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
Call
jev_browsewith a public URL and a narrow goal, for example: “Search wireless headphones, set the price filter below $100, and stop when results are visible.”Keep the returned
session_id.Call
jev_statuswhen you need to decide whether the page is ready or why it blocked.Call
jev_extract_productson a visible result/detail page.Call
jev_stopwhen 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-mcpThe 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 toolsjev_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.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| goal | Yes | ||
| max_steps | No |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| session_id | Yes |
TDQS
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.
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.
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.
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.
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.
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.
4 tool updates
v0.1.0- First observed
jev_browse - First observed
jev_extract_products - First observed
jev_status - First observed
jev_stop
TDQS
Scored across 4 tools
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.
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.
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.
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
Related MCP Connectors
Stealth web browser for agents: search, fetch, click, download and type in persistent MCP sessions.
A paid remote MCP for AI agent browser MCP session, built to return verdicts, receipts, usage logs,
Federated commerce search across independent WooCommerce merchants. Keyless, read-only MCP server.
Remote MCP server for product discovery catalog and retrieving product details.
Related MCP Servers
- AlicenseCqualityDmaintenanceA 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.351MIT
- AlicenseCqualityCmaintenanceProvides browser automation and web scraping as MCP tools, enabling autonomous URL ingestion, crawling, extraction, and anti-bot handling with interactive browser control.625MIT
- AlicenseAqualityBmaintenanceBrowser-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.3Apache 2.0
- AlicenseNot gradedqualityAmaintenanceMCP 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