Scout 225cbc74

MCP浏览器工具

提供方 felixgeelhaar

浏览器工具 未标注 API Key 社区 / 第三方 Claude DesktopClaudeCursorCline

Scout是一个轻量级浏览器自动化工具,提供单一二进制文件,支持从Go、shell、MCP服务器或聊天UI驱动真实浏览器,无需Node或Python运行时。

一句话选型结论

按资料字段整理

Scout 225cbc74 属于浏览器工具类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类浏览器工具 传输方式未标注 鉴权API Key 部署方式本地部署
GitHub 星标 1 仓库热度,无公开仓库时显示未标注
工具数 72 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

浏览器工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量72暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

浏览器自动化Go本地部署无服务器AI代理集成轻量级

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后客户端会列出约 72 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
自动操作网页

打开页面、点击、填表,把浏览器动作交给模型执行。

抓取结构化数据

把页面内容整理成表格或 JSON,省掉手工复制粘贴。

关键流程回归

按步骤检查页面是否正常,回归时少漏环节。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注 72 个工具,覆盖面较广,能满足多种调用。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在浏览器工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Scout 225cbc74当前 72 未标注 本地部署 无 2026-05-17
Playwright MCP Server 21 stdio · 本地进程 本地部署 有 2026-05-18
Fetch 9a2682de 1 SSE · 服务端推送 支持远程部署 有 2026-05-18
Browser 738d52bc 未标注 stdio · 本地进程 本地部署 有 2026-05-17
MCP 40600ece 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Skyvern MCP 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

浏览器工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方felixgeelhaar上游标注的维护方 felixgeelhaar
分类浏览器工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

15.6 KB
来自项目仓库与上游目录的原文,未做删改

Scout

Browser automation, one binary. The simpler alternative to Playwright — no Node, no Python, no runtime. Drive a real browser from Go, any shell, any AI agent (built-in MCP server), or a chat UI.

A single statically-linked scout binary gives you a CLI, an 87-tool MCP server (so any MCP-aware agent — Claude Desktop, Cursor, Cline, custom — has a browser), a conversational chat UI, and a Go library with Gin-like middleware composition. Same engine, four access points.```bash
brew install --cask klarlabs-studio/tap/scout-mcp


## vs. Playwright

| | Scout | Playwright |
|---|---|---|
| Install | one ~15 MB binary | npm + ~600 MB browser cache |
| Runtime dep | **none** (static) | Node.js always; Python/Java/.NET as wrappers |
| Drive from | Go, any shell, MCP, chat UI | TS/JS first-class; others lag |
| AI-agent native | **built-in** `scout mcp serve` | separate `playwright-mcp` project |
| Token-aware extraction | DOM diff, distillation, observation budgets (50–80% fewer tokens) | not provided |
| Action playbooks | record & replay deterministic JSON | codegen produces a script you maintain |
| Container deploy | drop into `scratch` or `distroless` | carry Node + browser binaries |
| CDP access | direct WebSocket, zero abstraction | internal protocol over CDP |

## Quick Start```bash
# CLI — visible browser, one-shot commands
scout observe https://example.com          # structured page snapshot
scout markdown https://news.ycombinator.com # page as compact markdown
scout screenshot https://github.com         # save screenshot
scout extract https://example.com h1        # extract element text
scout frameworks https://react.dev          # detect React, Vue, etc.

# MCP Server — give AI agents browser superpowers
claude mcp add scout -- scout mcp serve

# Browser UI — conversational browser automation
scout ui serve --provider=ollama --model=mistral
cd ui && npm install && npm run dev  # open http://localhost:3000

Install```bash

Homebrew

brew install --cask klarlabs-studio/tap/scout-mcp

Direct binary

curl -fsSL https://raw.githubusercontent.com/klarlabs-studio/scout/main/install.sh | bash

Go

go install go.klarlabs.de/scout/cmd/scout@latest

As a library

go get go.klarlabs.de/scout


## MCP Server — 77 Tools

Run `scout mcp serve` and any MCP-aware agent has a browser. No second project to install, no Node runtime, no Python interpreter — the binary is the server. Configure in any MCP client:```bash
claude mcp add scout -- scout mcp serve           # Claude Code
``````json
{"mcpServers": {"scout": {"command": "scout", "args": ["mcp", "serve"]}}}

Tool Categories

Category Tools
Navigation navigate, observe, observe_diff, observe_with_budget
Interaction click, click_label, click_text, type, hover, double_click, right_click, select_option, scroll_to, scroll_by, focus, drag_drop, dispatch_event
Forms fill_form, fill_form_semantic (checkbox/radio + state echo), discover_form
Extraction extract, extract_all, extract_table, auto_extract, scroll_and_collect, markdown, readable_text, accessibility_tree
Capture screenshot, annotated_screenshot, pdf
Network enable_network_capture, network_requests
Tabs open_tab, switch_tab, close_tab, list_tabs
Frameworks wait_spa, detect_frameworks, component_state, app_state
Playback start_recording, stop_recording, save_playbook, replay_playbook
Video start_screen_recording, stop_screen_recording
Smart Helpers check_readiness, suggest_selectors, session_history
Vision hybrid_observe, find_by_coordinates
Batch execute_batch
Iframe switch_to_frame, switch_to_main_frame
Trace start_trace, stop_trace
Cookies cookies_list, cookies_clear, cookies_set, dismiss_cookies
Diagnostics detect_dialog, detect_auth_wall, console_errors (incl. network 4xx/5xx), failed_requests, compare_tabs, upload_file
Utility has_element, wait_for, configure, set_viewport, web_vitals, select_by_prompt

All tools have MCP annotations (ReadOnly, OpenWorld, ClosedWorld, Idempotent) for smart auto-approval. Read-only tools like observe, extract, and screenshot run without permission prompts.

Runtime Configuration

Switch between headless and visible browser without restarting, and opt into local-dev workflows (loopback, private IPs):```
Agent: configure(headless: false) → browser window appears
Agent: navigate("https://...") → watch it work
Agent: configure(headless: true) → back to headless
Agent: configure(allow_private_ips: true) → unlock localhost / 192.168. / 10.
Agent: navigate("http://127.0.0.1:4173/") → drive your local dev server


The MCP server also reads `SCOUT_ALLOW_PRIVATE_IPS=1` at startup as a one-shot toggle for trusted environments.

### Screen Recording (video)

Record the active page as a video. Pure CDP — works in headless, no Playwright needed. Recording survives `navigate`, `open_tab`, and `switch_tab` calls in between, so a multi-page demo lands as one continuous clip:```
Agent: start_screen_recording({ width: 1280, height: 800, fps: 15, format: "webm" })
Agent: navigate("https://example.com")
Agent: click("#cta")
Agent: navigate("https://example.com/dashboard")   # recording continues across pages
Agent: stop_screen_recording()
       → { path: "/tmp/scout-rec-XXX.webm", format: "webm", encoder: "ffmpeg",
           frame_count: N, duration_ms: N }

If ffmpeg is on PATH, the result is encoded to WebM (libvpx-vp9) or MP4 (libx264). If not, scout returns the raw JPEG frames directory plus an ffmpeg concat list so you can encode offline. The result is always a file path, never base64 — never enters your LLM token budget.

Realistic FPS: ~10–15 on typical pages, capped at 30. Implementation polls Page.captureScreenshot (CDP Page.startScreencast events are silently dropped under --headless=new Chrome).

Browser UI

A conversational browser automation interface. Type natural language, watch the browser respond in real-time.```bash

Start the AG-UI server (Go backend)

scout ui serve --provider=ollama --model=mistral # local, no API key
scout ui serve --provider=claude # needs ANTHROPIC_API_KEY
scout ui serve --provider=openai --model=gpt-4o # needs OPENAI_API_KEY
scout ui serve --provider=groq --base-url=https://api.groq.com/openai --model=llama-3.3-70b-versatile

Start the Vue frontend

cd ui && npm install && npm run dev # http://localhost:3000


The UI streams AG-UI protocol events over SSE:
- **Chat panel** with markdown rendering and quick-action pills
- **Live browser viewport** with screenshot streaming and URL bar
- **Activity timeline** showing tool calls in real-time
- **Stop button** to cancel mid-stream

The Go server handles the agentic loop: LLM decides which scout tools to call, executes them, streams browser state deltas back to the frontend. Supports any OpenAI-compatible endpoint via `--base-url`.

## Agent Package (Go)

High-level Go API for callers that want to embed scout in a program. Structured output, auto-wait, goroutine-safe. Most users reach scout through the CLI or MCP server above — this section is for the Go-library path.```go
session, _ := agent.NewSession(agent.SessionConfig{Headless: true})
defer session.Close()

// Navigate and observe
session.Navigate("https://example.com")
obs, _ := session.Observe()               // links, inputs, buttons, text + action costs

// DOM diff — only what changed (saves 50-80% tokens)
session.Click("#submit")
_, diff, _ := session.ObserveDiff()
// diff.Classification: "modal_appeared"
// diff.Summary: "Modal/dialog appeared: Login required"

// Semantic form filling — no CSS selectors
session.FillFormSemantic(map[string]string{
    "Email": "user-example", "Password": "secret",
})

// Visual grounding — click by number, not selector
result, _ := session.AnnotatedScreenshot()  // numbered labels on elements
session.ClickLabel(7)                        // click element [7]

// Multi-tab coordination
session.OpenTab("pricing", "https://example.com/pricing")
session.SwitchTab("default")

// Framework detection (19 frameworks)
frameworks, _ := session.DetectedFrameworks() // ["react", "nextjs"]
state, _ := session.ComponentState("#app")    // read React/Vue state

// Network capture — read API responses directly
session.EnableNetworkCapture("/api/")
captured := session.CapturedRequests("/api/users")

// Action replay — record once, replay without LLM
session.StartRecordingPlaybook("login-flow")
// ... do stuff ...
pb, _ := session.StopRecordingPlaybook()
agent.SavePlaybook(pb, "login.json")
// Later: session.ReplayPlaybook(pb)  // 100x cheaper

// Persistent profiles
session.SaveProfile("session.json")   // cookies + localStorage
session.LoadProfile("session.json")

// Content distillation (5 levels)
session.Markdown()          // ~2-8KB compact markdown
session.ReadableText()      // ~1-4KB main content only
session.AccessibilityTree() // ~1-4KB semantic tree
session.ObserveWithBudget(500) // fit in ~500 tokens

Core Library (Go)

Gin-like Engine/Context/Group/HandlerFunc with middleware composition. The lowest-level Go API — use it when you want full control of task lifecycle, named groups, and middleware chains:```go
engine := browse.Default(browse.WithHeadless(true))
engine.MustLaunch()
defer engine.Close()

engine.Use(middleware.Stealth())
engine.Use(middleware.Retry(middleware.RetryConfig{MaxAttempts: 3}))
engine.Use(middleware.Timeout(30 * time.Second))

admin := engine.Group("admin", middleware.BasicAuth("admin", "secret"))
admin.Task("export", func(c *browse.Context) {
c.MustNavigate("https://app.example.com/admin")
table, _ := c.ExtractTable("#users")
c.Set("data", table)
})

engine.RunGroup("admin")


### Middleware

| Category | Middleware |
|----------|-----------|
| **Resilience** | `Retry`, `Timeout`, `CircuitBreaker`, `RateLimit`, `Bulkhead` |
| **Auth** | `BearerAuth`, `BasicAuth`, `CookieAuth`, `HeaderAuth` |
| **Anti-detection** | `Stealth` (10 patches: webdriver, plugins, WebGL, etc.) |
| **Network** | `BlockResources`, `WaitNetworkIdle` |
| **Utilities** | `ScreenshotOnError`, `SlowMotion`, `Viewport` |

## CLI

The CLI is a deliberate **one-shot tier**: each command launches a browser,
navigates, runs one read/diagnostic action, prints the result, and exits.
Stateful interactive flows (click→type→submit, multi-tab, live cookie/network
manipulation) live in the MCP server (`scout mcp serve`) and chat UI
(`scout ui serve`), which keep a session alive across actions.

CLI defaults to visible browser (`--headless` to hide):```bash
scout navigate <url>                  # page info as JSON
scout observe <url>                   # structured observation
scout markdown <url>                  # compact markdown
scout readable <url>                  # main readable content (boilerplate stripped)
scout accessibility <url>             # semantic accessibility tree
scout screenshot <url> [--output f]   # save screenshot
scout pdf <url> [--output f]          # save PDF
scout extract <url> <selector>        # extract text
scout table <url> <selector>          # extract a table as structured rows
scout auto-extract <url>              # auto-detect dominant data pattern
scout eval <url> <expression>         # run JavaScript
scout form discover <url>             # discover form fields
scout frameworks <url>                # detect frameworks
scout app-state <url>                 # global app/store state (JSON)
scout aria <url>                      # ARIA violation report (JSON)
scout vitals <url>                    # Core Web Vitals (JSON)
scout console <url>                   # console errors + network 4xx/5xx (JSON)
scout dialog <url>                    # detect visible modal/dialog (JSON)
scout auth-wall <url>                 # detect login/auth wall (JSON)
scout cookies <url>                   # list cookies (values redacted)
scout watch <url> [--interval=5s]     # live-watch page changes
scout pipe <command> [selector]       # batch process URLs from stdin
scout record <url> [--output f]       # interactive recording → playbook
scout mcp serve                       # start MCP server
scout ui serve [flags]                # start chat UI
scout version                         # print version

Architecture```

scout/
├── browse.go, engine.go, context.go # Gin-like API
├── page.go, selection.go # CDP page & element interaction
├── recorder.go # Action playbook recording (Navigate/Click/Type → JSON)
├── middleware/ # stealth, resilience, auth, network
├── agent/ # AI agent API (50+ methods)
│ ├── session.go # Session lifecycle, Navigate, Click, Type
│ ├── observe.go, diff.go # Observe, ObserveDiff, cost estimation
│ ├── content.go # Markdown, ReadableText, AccessibilityTree
│ ├── form.go # DiscoverForm, FillFormSemantic, MatchFormField
│ ├── annotate.go # AnnotatedScreenshot, ClickLabel
│ ├── network.go # EnableNetworkCapture, CapturedRequests
│ ├── spa.go # DetectedFrameworks, ComponentState, GetAppState
│ ├── tabs.go # OpenTab, SwitchTab, CloseTab, ListTabs
│ ├── playbook.go # StartRecording, ReplayPlaybook, SavePlaybook
│ ├── interact.go # Hover, DragDrop, SelectOption, ScrollTo
│ ├── profile.go # CaptureProfile, ApplyProfile, SaveProfile
│ ├── selector.go # Playwright :text() selector translation
│ ├── budget.go # ObserveWithBudget, EstimateTokens
│ ├── nlselect.go # SelectByPrompt, fuzzy NL element matching
│ ├── batch.go # ExecuteBatch, sequential multi-action
│ ├── vision.go # HybridObserve, FindByCoordinates
│ ├── trace.go # StartTrace, StopTrace, action tracing
│ ├── screencast.go # StartScreenRecording / StopScreenRecording — video via captureScreenshot polling + ffmpeg encode
│ ├── iframe.go # SwitchToFrame, SwitchToMainFrame
│ └── vitals.go # WebVitals (LCP/CLS/INP)
├── internal/cdp/ # WebSocket CDP client (context-aware)
├── internal/launcher/ # Chrome process management
├── cmd/scout/ # CLI + MCP server (87 tools)
└── docs/ # Landing page (GitHub Pages)


## Security

Vulnerability scanning runs on every push and PR via `nox`. Findings are uploaded to GitHub code scanning, annotated inline on PRs, and gated against `.nox/baseline.json` so regressions block merges. The status badge in the header reflects the latest main-branch scan.

`nox` also drives dependency remediation in place of Dependabot — the Nox Remediate workflow runs weekly (Monday 06:00 UTC) and on demand, executing `nox fix` against fresh OSV.dev findings and opening a single PR with the verified upgrades.```bash
# Local scan
nox scan -severity-threshold high .

# Local fix
nox fix -input findings.json

License

MIT

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Scout 225cbc74 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Scout 225cbc74 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Scout 225cbc74 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Scout 225cbc74 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Scout 225cbc74 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Cline;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Scout 225cbc74 能提供哪些能力?

资料显示约 72 个工具;能力标签包括 浏览器自动化、轻量级、Go、Claude。具体工具清单以官方文档为准。

Scout 225cbc74 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Scout 225cbc74 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。