Wigolo

MCP搜索检索

提供方 KnockOutEZ · 包名 wigolo

搜索检索 stdio · 本地进程 API Key 社区 / 第三方 ClaudeCursorVS CodeWindsurf
查看接入方式

The go-to web for your AI coding agent — local-first search, fetch, crawl & research over MCP. No API keys, no cloud, $0/query. Public beta.

一句话选型结论

按资料字段整理

Wigolo 属于搜索检索类 MCP 服务器,stdio · 本地进程,API Key,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

searchwebcrawl

安装与配置

stdio · 本地进程 API Key
客户端在本机拉起子进程,数据不出本机
npx -y wigolo

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 node,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
联网搜索取证

让模型查最新资料并给出出处。

资料聚合

把一个主题的网页、文档集中抓回来整理。

情报与竞品检索

按关键词持续检索行业动态和竞品信息。

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Wigolo当前 未标注 stdio · 本地进程 本地部署 有 未标注
Brave Search 433812ff 2 未标注 未标注 无 2026-05-17
Sequentialthinking 1 SSE · 服务端推送 远程部署 有 2026-05-18
Baidu Netdisk 未标注 未标注 未标注 无 2026-05-17
ragflow 未标注 stdio · 本地进程 本地部署 有 2026-04-11
mindsdb (430e18) 未标注 未标注 未标注 有 2026-05-17

服务器档案

搜索检索
字段来自项目仓库与公开索引,中文说明由本站标注
提供方KnockOutEZ上游标注的维护方 KnockOutEZ
分类搜索检索本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时wigolo · node本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

Local-first web intelligence for AI agents — no keys, no cloud, no metered bill.

works with Claude Code · Cursor · Codex · Gemini CLI · OpenCode · VS Code · Windsurf · Zed · Antigravity

and beyond LangChain · CrewAI · LlamaIndex · Vercel AI SDK · n8n & self-hosted agents · any MCP client · plain REST

sponsored by

Join the community on Discord — questions, help, and what's being built next.

New features and updates ship steadily. Follow @yourtowhid on X for all of it and new ways to use wigolo, and reach out there for collaborations or feedback · also on LinkedIn


wigolo gives an AI agent one surface for everything web-related: search, fetch, crawl, extract, cache, find-similar, research, and autonomous gather loops. It runs wherever your agent runs — as an MCP server next to your coding agent, as a REST/MCP endpoint on the box where your self-hosted agents live, or embedded through an SDK inside your own app. The core tools need no API keys, nothing it touches leaves ~/.wigolo/, and no bill grows with how much your agent thinks.

Quickstart```bash

npx wigolo init # set up the local engine — any system
npx wigolo init --agents=claude-code,cursor # …or set up + wire your day-to-day agents in one command


Requires **Node ≥ 20** and ~1.5 GB of free disk on macOS, Linux, or Windows. Bare `init` sets up the local engine: it downloads the browser engine and on-device models, runs a health check, and reports each component. Adding `--agents` wires the named agents in the same run, so a coding agent you use daily is ready in one command.

- **Supported agents** — `--agents` takes any of `claude-code` · `cursor` · `codex` · `gemini-cli` · `opencode` · `vscode` · `windsurf` · `zed` · `antigravity` (comma-separated); wigolo writes the MCP config and, where supported, instructions for each.
- **Any other setup** — any MCP client, agent framework, or self-hosted agent registers `npx -y wigolo` in its own MCP config. The installation guide has the exact config block for every client, plus Docker, Homebrew, and single-file-binary channels.
- **More on the way** — the supported list keeps growing, and a PR to add your agent is welcome; see CONTRIBUTING.md.
- **Interactive setup** — `--interactive` is a plain-text flow; `--wizard` is the full terminal TUI.
- **Defer downloads** — `--no-warmup` waits until first use. A failed component download never fails setup; init reports what's not ready with the exact fix and still completes.

`init` is unattended by default, so it's safe in scripts and CI, and any setup problem surfaces right here in the per-component report, before your agent's first call. **Search, fetch, crawl, extract, cache, and find-similar work with no API key.** Check it's healthy anytime:```bash
npx wigolo doctor

To remove everything cleanly, run npx wigolo config --uninstall --yes. You can also paste the installation guide into any AI assistant and let it do the setup; it's written to be self-contained.

Recommended — a free key for research & agent

Search, fetch, crawl, extract, cache, and find-similar are fully keyless. research, agent, and search format=answer use an LLM to write the synthesized, cited answer. Without one they hand back a raw brief and evidence for your agent to assemble. A free Gemini key turns that into a finished answer:```bash
export WIGOLO_LLM_PROVIDER=gemini
export GEMINI_API_KEY=<free-key> # grab one at aistudio.google.com/apikey — the free tier is plenty


Any provider works (`anthropic` · `openai` · `groq`), or stay fully local and keyless with `WIGOLO_LLM_PROVIDER=ollama` (or any OpenAI-compatible URL). Set it in your shell or your agent&#x27;s MCP `env` block. Providers, models, and the keyless local-model ladder are in the configuration guide.

## What your agent gets back

Every search result is evidence the agent can act on. It carries a verbatim excerpt pinned to its exact position in the source, a citation ID the agent can quote, and a score it can inspect (abridged real shape):```jsonc
{
  &quot;results&quot;: [{
    &quot;title&quot;: &quot;Logical replication - PostgreSQL docs&quot;,
    &quot;url&quot;: &quot;https://www.postgresql.org/docs/current/logical-replication.html&quot;,
    &quot;excerpt&quot;: &quot;Logical replication is a method of replicating data objects…&quot;,
    &quot;citation_id&quot;: &quot;src-1&quot;,
    &quot;source_span&quot;: { &quot;start&quot;: 1042, &quot;end&quot;: 1305 },          // byte-exact provenance
    &quot;evidence_score&quot;: { &quot;final&quot;: 0.86, &quot;semantic&quot;: 0.91, &quot;lexical&quot;: 0.78, &quot;engine_consensus&quot;: 3 }
  }],
  &quot;citations&quot;: [{ &quot;id&quot;: &quot;src-1&quot;, &quot;url&quot;: &quot;…&quot; }],
  &quot;freshness_signal&quot;: { &quot;published&quot;: &quot;2026-05-12&quot;, &quot;confidence&quot;: &quot;high&quot; }
}

Weak results get flagged as junk by wigolo's own scorer. Failed engines are reported and stale cache is labeled, so the agent always knows what it's standing on. Full response contracts per tool are in the tools reference.

Tools

Tool What it does
🔎 search Multi-engine web search (18 direct adapters) with rank fusion, ML reranking, and an explainable per-result score. Pass a query array for parallel breadth. Scope by domain and time range, match an exact phrase, or return image results.
📄 fetch Load one URL through a tiered router that auto-escalates from plain HTTP to a headless browser engine on anti-bot challenges or SPA shells. Clean markdown + metadata + links. Handles PDFs, a single-heading section, authenticated sessions, and page actions (click / type / scroll / screenshot).
🕸️ crawl Multi-page crawl — BFS, DFS, sitemap, or map-only. Per-domain rate limits, robots.txt respect, boilerplate dedup.
🧩 extract Structured data from a page: tables, metadata, JSON-LD, brand identity, named schemas (Article / Recipe / Product / …), or any custom JSON Schema.
💾 cache Query everything already seen — keyword or hybrid semantic. Plus stats, clear, and change detection.
🧲 find_similar Pages similar to a URL or a concept, via 3-way fusion of keyword + semantic + live web.
🧠 research Decompose a question → fan out sub-queries → fetch sources → synthesize a cited report (or a structured brief the host LLM writes from).
🤖 agent Autonomous gather loop: plan → search → fetch → extract → synthesize, with a step log, time budget, and optional output schema.
🔁 diff + ⏱️ watch See exactly what changed on a page since last visit; re-check on demand and deliver changes to a webhook.

Every tool also runs from the terminal (wigolo search &quot;…&quot; --json), from an interactive shell with NDJSON piping (wigolo shell), over REST, and through the SDKs — CLI reference. Per-tool guides with the full parameter set are in docs/tools.md; runnable examples are in examples/.

Why it's different

wigolo isn't a free stand-in for the paid tools — it's built to match them. It's a focused web layer for your agents: an MCP and REST surface they call directly, with the search and extraction quality the paid services charge for. What separates it:

  • Built for agents. One MCP call fans out many queries across many engines in parallel, which a serial host tool-loop can't replicate. Every result carries transparent per-result scoring, and output is budget-aware.
  • Honest output. Stale cache, failed fetches, degraded backends, and truncation are surfaced in the result. When a bot-protected page can't be read, you get a labeled blocked_by_challenge failure, not a challenge shell returned as content.
  • $0 per query, free to re-query. Default search talks to public engines through direct adapters; the reranker and embeddings run on-device. Every response is cached, so asking again is instant and costs nothing.
  • Private by default. Cache, embeddings, models, and config live under ~/.wigolo/. Nothing reaches a third party unless you explicitly opt into an LLM for synthesis.

Here's what one real result looks like, dissected. It includes the failed engine and the weak result, because those are part of the answer too:

Benchmark

> All four tools converged on the same core answer, and only one of them handed back verbatim, byte-pinned evidence while doing it.

One cold query ran live inside a single Claude Fable 5 session, fanned out to four web tools on equal footing (built-in WebSearch, wigolo, Tavily, Exa), and was judged by the agent on the evidence alone. All four converged on the same answer and the same top source, so the parity is demonstrated on-screen. wigolo alone returned verbatim excerpts pinned to byte-offset source spans, an explainable score decomposition, and live per-engine telemetry, and its own scorer flagged two weak results as junk. The cloud tools earn their place too: Exa rendered the official docs' comparison matrix in full. Run your own query and you'll see the same shape.

How it compares

wigolo Firecrawl Exa Tavily
Multi-engine web search ✅ ✅ ✅ ✅
Fetch & structured extraction ✅ ✅ ✅ ✅
Whole-site crawl & map ✅ ✅ — ✅
Verbatim excerpts pinned to byte-offset source spans ✅ — — —
Explainable per-result score decomposition ✅ — — —
Persistent local memory — re-query instantly, offline ✅ — — —
Query data stays on your machine ✅ — — —
API key / account none required required required
Cost per query $0 metered metered metered

Feature standing as of July 2026 — check each vendor's docs for current state.

That last row compounds, because agents ask in bursts:

Beyond your editor

The same ten tools serve every kind of agent, over whichever surface fits: MCP for coding agents, REST for everything else, SDKs to embed, and framework wrappers to drop in.

REST API — wigolo serve

One process exposes a plain-JSON REST API next to the MCP transport. No MCP client needed, just curl:```bash
wigolo serve # 127.0.0.1:3333 — loopback is open; off-loopback requires a token

curl -sX POST http://127.0.0.1:3333/v1/search \
-H 'Content-Type: application/json' \
-d '{"query":"local-first software","max_results":5}'


`POST /v1/{tool}` covers all ten tools, `GET /openapi.json` is the OpenAPI 3.1 contract, and `/mcp` + `/sse` serve remote MCP clients from the same port. Bind past loopback and a bearer token is required, so the server fails closed by default. Point n8n, a Hermes-style assistant, or any self-hosted agent at it. → REST API

### SDKs — TypeScript &amp; Python

Thin, typed clients with an embedded local mode that finds or starts the daemon for you. No separate `serve` step.

**TypeScript** — `npm install wigolo-sdk` (zero-dep; Node / Bun / Deno / edge):```ts
import { createLocalClient } from &#x27;wigolo-sdk/local&#x27;;

const { client, close } = await createLocalClient();   // reuse a running daemon, or spawn one
const res = await client.search({ query: &#x27;local-first web search&#x27;, max_results: 5 });
console.log(res.results.map((r) =&gt; r.title));
await close();                                          // stops the daemon only if this call spawned it

Python — pip install wigolo (standard library only; sync + async):```python
from wigolo import local_client

with local_client() as client: # reuse a healthy daemon, or spawn one
res = client.search(query="local-first web search", max_results=5)
for r in res["results"]:
print(r["title"], r["url"])


→ SDKs &amp; embedded mode

### Framework integrations

Drop wigolo&#x27;s tools into the framework you already use. You get the full ten-tool surface, including the cache / find_similar / research / agent that most framework web-tools don&#x27;t ship:

| Framework | Package | What you get |
|-----------|---------|--------------|
| **LangChain** | `wigolo-langchain` | each tool as a `BaseTool`, plus a `BaseRetriever` over search / find_similar for RAG |
| **CrewAI** | `wigolo-crewai` | `wigolo_tools()` → hand the set to any crew |
| **LlamaIndex** | `wigolo-llamaindex` | a `BaseReader` that loads fetched / crawled / searched pages as documents |
| **Vercel AI SDK** | `wigolo-vercel-ai-sdk` | tool factories for `generateText` / `streamText`, edge-friendly |

→ Framework integrations

### Docker```bash
# stdio MCP — wire it into any MCP client as command: docker
docker run -i --rm -v wigolo-data:/data ghcr.io/knockoutez/wigolo

# HTTP server for remote / multi-client use
docker run -p 3333:3333 -v wigolo-data:/data \
  -e WIGOLO_API_TOKEN=a-long-random-secret \
  ghcr.io/knockoutez/wigolo serve --host 0.0.0.0

The slim image lazy-loads models into the volume; ghcr.io/knockoutez/wigolo:latest-full preinstalls the browser engine. Versioned releases use the same -full suffix (for example, 0.3.1-full). Also on Docker Hub as towhid69420/wigolo. → installation & all channels

Agent skills

An 11-pack skill catalog teaches your coding agent to drive each tool well. It's installed by init and managed with wigolo skills add · list · remove. → skills

One note for self-hosters: some challenge-protected sites score IP reputation, so a datacenter IP won't clear walls a home connection would. wigolo labels those failures, and the self-hosting guide covers the opt-in proxy answer.

Star history

Refreshed daily from the GitHub API. Add a ⭐ if wigolo is useful to you.

Architecture

A single Node process speaks MCP (JSON-RPC over stdio). Everything heavy is local and lazy-loaded, so a zero-key install pays nothing for the parts it isn't using.```mermaid
flowchart TD
A["🤖 AI agent<br/>any MCP client · REST · SDK"]
A -->|MCP over stdio| B["<b>wigolo</b><br/>10 tools · dynamic instructions<br/>in-process browser pool + cache + models"]

B --&gt; C{&quot;Tool layer&quot;}
C --&gt; T1[&quot;search · fetch · crawl · extract&quot;]
C --&gt; T2[&quot;cache · find_similar · research · agent&quot;]

T1 --&gt; F[&quot;⚙️ Fetch router&lt;br/&gt;tiered escalation, learned per domain&quot;]
T1 --&gt; S[&quot;⚙️ Search&lt;br/&gt;18 engines → rank fusion → ML rerank&lt;br/&gt;&lt;i&gt;explainable evidence score&lt;/i&gt;&quot;]
T2 --&gt; DB[(&quot;🗄️ Local cache&lt;br/&gt;keyword + vector index&quot;)]
T2 --&gt; ML[&quot;🧠 On-device ML&lt;br/&gt;embeddings + reranker&quot;]

F -.-&gt;|optional| LLM[&quot;☁️ LLM&lt;br/&gt;synthesis only · opt-in&quot;]
S -.-&gt;|optional| SX[&quot;🔀 Aggregator backend&lt;br/&gt;opt-in legacy / hybrid&quot;]

F --&gt; WEB[&quot;🌍 Public web&quot;]
S --&gt; WEB

style B fill:#7c3aed,stroke:#5b21b6,color:#fff
style WEB fill:#0ea5e9,stroke:#0369a1,color:#fff
style DB fill:#1e293b,stroke:#334155,color:#fff
style LLM stroke-dasharray: 5 5
style SX stroke-dasharray: 5 5

- **Code beats model.** Deterministic work stays off the LLM: canonicalization, rank fusion, dedup, and schema matching. The model is reserved for judgment, opt-in, and capped per request. LLM-filled fields are checked against the source and nulled if absent.
- **Signal-driven routing.** The fetch ladder escalates to a real browser on observable signals, not domain guesses: SPA markers, challenge bodies, thin content. It learns per domain, unlearns when a site stops needing it, and `wigolo tune list` shows you exactly what it learned.
- **Reads pages the way a browser does.** Tiered fetching waits out interstitial challenges and reuses clearances per domain, politely: robots.txt respected, per-domain rate limits, research-grade volumes. When a wall stays up, the failure is labeled and reported.

## Configuration

A clean install works out of the box. Three settings raise output quality:```bash
# 1. Synthesis — the biggest lever (research / agent / search-answer write real prose)
export WIGOLO_LLM_PROVIDER=gemini                   # or anthropic / openai / groq / ollama (keyless)
export GEMINI_API_KEY=&lt;your-key&gt;

# 2. Wider retrieval funnel
export WIGOLO_SEARCH=hybrid                         # core engines + aggregator fallback
export WIGOLO_GITHUB_TOKEN=...                      # GitHub code search 10 → 30 req/min

# 3. Land more fetches, stay warm
export WIGOLO_TLS_TIER=auto                         # per-domain learned fetch hardening
export WIGOLO_EAGER_WARMUP=1                        # pay the ~1s model load up front

Per-call habits that pay off: query arrays ([&quot;a&quot;,&quot;b&quot;,&quot;c&quot;]) for parallel breadth · search_depth: &quot;deep&quot; for queries that matter · include_domains as a hard filter for docs lookups. The full reference covers every environment variable, config-file key, search backend, cache TTL, and serve limit; it's in the configuration guide.

Docs & examples

docs/ — the complete manual:

examples/ — runnable, each with a README (and most with a terminal recording): one-shot CLI, NDJSON shell pipelines, REST via curl, TypeScript & Python SDKs, Vercel AI SDK tools, pointing self-hosted n8n at a remote wigolo, watch-with-webhook, and writing your own search-engine plugin. The docs are also rendered on the site at wigolo.app/docs.

Beta & feedback

wigolo is in public beta. Everything documented here works and is held to a 7,600-test suite; it's stable, and beta is about the polish bar. It stays beta until enough people have used it, kicked it, and starred it that calling it v1 means something. Your feedback shapes what comes next, and every report is read, usually the same day:

  • 🐛 Report a bug — broke, misbehaved, surprised you
  • 💡 Request a feature — something it should do
  • 💬 Ask anything — questions, setups, show & tell

If wigolo earns a place in your setup, three things keep it going: a ⭐ star (it's how open source gets found), a ☕ coffee (the open-source version is the full product; commercial licenses fund it, not gated features), or an email that goes straight to the one developer who wrote the code.

Troubleshooting

wigolo doctor names any broken component and the exact env var or command that fixes it; wigolo doctor --fix repairs the common cases, and wigolo verify health-checks every component. A component failing during init doesn't break wigolo: init still exits 0, and core search / fetch / crawl / extract / cache work with no models and no browser. Quick hits:

  • Slow or failed downloads — re-run wigolo warmup --all (or --browser / --embeddings / --reranker); they resume and retry.
  • Browser won't launch on Linux — wigolo warmup --browser installs the OS libraries (or prints the exact command).
  • Native build error / unusual Node — use an LTS — Node 22 or 24 — or Node 26 (supported; Current until it becomes LTS).
  • Behind a proxy — USE_PROXY=true + PROXY_URL; add NODE_EXTRA_CA_CERTS for TLS-inspecting proxies.
  • Your agent asks permission on every call — allow the tools in your client, then restart it; rules are read at session start. Details.

The full guide covers per-symptom fixes, a "what still works when X fails" map, platform notes (incl. linux-arm64), and offline installs: docs/troubleshooting.md.

FAQ

Free? What's the catch?

No catch by design. The expensive parts (ranking, embeddings, the browser engine) run on your hardware, so there's no per-query cost to recover and no reason for a meter. It's funded by commercial licenses and sponsors, and the AGPL legally prevents a switch into a closed hosted product.

Is the quality really on par with the paid services?

The benchmark section above is a live 4-way run you can reproduce: everyday agent queries land at parity, the paid tools still win some deep-extraction edge cases, and crawling is where wigolo is strongest. Every result shows its scoring, so you don't have to take anyone's word for it.

Won't public search engines block or rot?

It's engineered for exactly that: 18 engines fused with rank fusion (any one failing barely moves results), a tiered fetch ladder with per-domain learning, and an optional aggregator fallback. Degraded backends are reported in the output, and the local cache means everything already seen keeps working regardless.

Is this kind of scraping OK?

wigolo reads the public web the way a browser does: robots.txt respected by default, per-domain rate limits, and research-grade volumes for one agent on one machine. It sits deliberately at the polite end of the spectrum.

Can I use this at work?

Yes. If you're a company or building a commercial product on wigolo, please take a commercial license or sponsor the project. See LICENSING.md.

Why 1.5 GB of disk?

That's the on-device brain: a full browser engine plus the ranking and embedding models the cloud services run on their side and bill you for. Once it's on disk, every query uses it for free.

Available on

  • npm — wigolo (primary channel — the Quickstart above)
  • PyPI — wigolo (Python SDK)
  • Docker — ghcr.io/knockoutez/wigolo · towhid69420/wigolo
  • Official MCP Registry — io.github.KnockOutEZ/wigolo
  • Directories — Glama · Smithery · mcp.so · LobeHub

Homebrew, curl | sh, and the single-file binary are covered in the installation guide. Use one channel per machine; they all share ~/.wigolo.

Sponsors

Thank you to the sponsors below, who help keep wigolo maintained and free for everyone to use. Their support goes straight into the work.

TestMu AI (formerly LambdaTest) is the world's first full-stack agentic AI quality engineering platform, trusted by 18,000+ enterprises.

wigolo is free for everyone. If you or your company would like to help keep it maintained, there's room for more sponsors — reach out at ktowhid20@gmail.com, or see what sponsorship includes and the terms in SPONSORS.md. A one-off via Buy Me a Coffee is welcome too.

Contributing

Bug reports, feature requests, and PRs are all welcome; see CONTRIBUTING.md. Keep tool handlers thin, add tests, and run the suite before opening a PR. The friendliest entry point is the plugin system for custom search engines and extractors: add a search engine in ~100 lines, with a template in examples/plugin-search-engine.

License

Free and open source under the GNU AGPL-3.0, and it'll stay that way. If you're a company, or you're making money with wigolo, please take a commercial license or sponsor the project. That's what keeps it maintained. See LICENSING.md.

See SECURITY.md to report a vulnerability and TRADEMARK.md for use of the name.

wigolo is open source, free, and actively maintained.
If it saves you a metered search bill, a ⭐, a sharp issue, or a ☕ coffee helps keep it sustainable.

Built and maintained by @KnockOutEZ · ktowhid20@gmail.com · X · LinkedIn

常见问题

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

在客户端按下面的安装命令接入:npx -y wigolo。对应的包名是 wigolo。装完在客户端配置里引用同一个包或端点。

Wigolo 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Wigolo 收费吗?

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

Wigolo 需要 API Key 吗?

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

Wigolo 支持哪些客户端?

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

Wigolo 能提供哪些能力?

资料显示能力标签包括 search、web、crawl、scraping、extraction、research。具体工具清单以官方文档为准。

Wigolo 需要什么运行环境?

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

Wigolo 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

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

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