Aggregates web, image, and WeChat search results from multiple engines and fetches page or PDF content for AI agents.
Also known as xiaonerner0821/prismsearch
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.3.3
- Last commit
- Nov 13, 2026
- License
- Apache-2.0
What is PrismSearch MCP?
PrismSearch aggregates web, image, and WeChat search results from multiple engines and fetches page or PDF content for AI agents.
Summary generated from the project's README
About PrismSearch MCP server
Providing multi-perspective web search capabilities to AI agents is what PrismSearch enables for developers using clients like Claude Code, Cursor, or DeepSeek Harness. It aggregates results from nine different sources, including Google, Bing, Baidu, and WeChat Official Account articles, to ensure agents do not have to rely on closed-book knowledge. The server works via local stdio or remote Streamable HTTP transport, making it compatible with a wide range of MCP-capable environments.
Users can perform web searches, image searches, and retrieve content from specific URLs or PDFs using the fetch_page tool. A significant advantage is that it requires no search accounts or API keys out of the box because it scrapes public result pages, though it can utilize Brave or Google API keys for increased reliability. It also includes built-in ad filtering to remove sponsored results and features an automatic fallback system that switches engines if one is blocked or rate-limited.
What you can do with it
- 1Perform multi-engine web searchesAn AI agent can search across multiple engines simultaneously to get a broader range of results for a query.
- 2Extract content from web pages and PDFsA developer can instruct an agent to read the full text of a specific website or a PDF document to answer complex questions.
- 3Access WeChat Official Account contentUsers can retrieve articles specifically from the WeChat ecosystem to supplement their research.
Written from the project's README. Every use case is checked against a quote from it.
How to install PrismSearch MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall PrismSearch MCP in Claude Code
$ claude mcp add --env 'BRAVE_API_KEY=<YOUR_BRAVE_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' prismsearch -- npx -y prismsearchInstall PrismSearch MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"prismsearch": {
"command": "npx",
"args": [
"-y",
"prismsearch"
],
"env": {
"BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>"
}
}
}
}Install PrismSearch MCP in VS Code
.vscode/mcp.json
{
"servers": {
"prismsearch": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"prismsearch"
],
"env": {
"BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>"
}
}
}
}Install PrismSearch MCP in VS Code CLI
$ code --add-mcp '{"name":"prismsearch","type":"stdio","command":"npx","args":["-y","prismsearch"],"env":{"BRAVE_API_KEY":"<YOUR_BRAVE_API_KEY>","GOOGLE_API_KEY":"<YOUR_GOOGLE_API_KEY>"}}'Install PrismSearch MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"prismsearch": {
"command": "npx",
"args": [
"-y",
"prismsearch"
],
"env": {
"BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>"
}
}
}
}Install PrismSearch MCP in Codex
$ codex mcp add prismsearch --env 'BRAVE_API_KEY=<YOUR_BRAVE_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' -- npx -y prismsearchInstall PrismSearch MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.prismsearch] command = "npx" args = ["-y", "prismsearch"] [mcp_servers.prismsearch.env] BRAVE_API_KEY = "<YOUR_BRAVE_API_KEY>" GOOGLE_API_KEY = "<YOUR_GOOGLE_API_KEY>"
Install PrismSearch MCP in Gemini CLI
$ gemini mcp add -s user -e 'BRAVE_API_KEY=<YOUR_BRAVE_API_KEY>' -e 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' prismsearch npx -- -y prismsearchInstall PrismSearch MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"prismsearch": {
"command": "npx",
"args": [
"-y",
"prismsearch"
],
"env": {
"BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>",
"GOOGLE_API_KEY": "<YOUR_GOOGLE_API_KEY>"
}
}
}
}Configuration
BRAVE_API_KEYSecretBrave Search API key (optional, comma-separated for rotation)
GOOGLE_API_KEYSecretGoogle Custom Search API key (optional, comma-separated for rotation)
GOOGLE_CSE_IDGoogle Programmable Search Engine ID (cx), used with GOOGLE_API_KEY
PRISMSEARCH_AUTH_TOKENSPRISMSEARCH_CACHE_BACKENDPRISMSEARCH_CACHE__BACKENDPRISMSEARCH_CACHE__TTLPRISMSEARCH_CONFIGPath to a YAML/JSON/TOML config file (optional)
PRISMSEARCH_ENGINES__BING__ENABLEDPRISMSEARCH_ENGINES__DUCKDUCKGO__ENABLEDPRISMSEARCH_FETCHER__BROWSER__ENABLEDPRISMSEARCH_HOMELocal data directory for SQLite cache and default config lookup (optional)
PRISMSEARCH_REDIS_PASSWORDPRISMSEARCH_SECURITY__RATE_LIMIT__MAX_REQUESTSPRISMSEARCH_SECURITY__SSRF__WHITELISTPRISMSEARCH_SERVER_TRANSPORTPRISMSEARCH_SERVER__ALLOWED_HOSTSPRISMSEARCH_WORKERS_ENABLEDPRISMSEARCH_WORKER_TOKEN
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work · What to fix for more points
- Source repository linked and reachablexiaonerner0821/prismsearch is public and reachablegithub.com/xiaonerner0821/prismsearch ↗Pass
- Package names this repository as its sourceprismsearch names xiaonerner0821/prismsearch as sourcenpmjs.com/package/prismsearch ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for prismsearchnpmjs.com/package/prismsearch/v/0.3.3#provenance ↗Pass
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/xiaonerner0821/prismsearch ↗Pass
- OpenSSF ScorecardOpenSSF Scorecard 6.2 / 10; weakest: Maintained 0, Code-Review 0, CII-Best-Practices 0scorecard.dev/viewer/?uri=github.com/xiaonerner0821/prismsea ↗Partial 9/15
- Package name not close to a popular packageNo popular package one edit away from prismsearchPass
- No critical advisory in the package or its dependencies185 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubA multi-engine web search MCP (Model Context Protocol) server that aggregates search results from multiple search engines.
Like a prism splits light into a spectrum, PrismSearch disperses your search queries across multiple engines for multi-perspective results.
Why: web search for your AI agent, no search account required
The built-in web search of AI coding agents such as Claude Code and DeepSeek Harness usually depends on an official account or a separately configured search API key. Use a third-party model, go through your own gateway, or simply skip the search account, and the built-in search is often unavailable — the agent ends up coding "closed-book".
PrismSearch adds that capability back with one command:
- No account, no API key out of the box: the default engines (Bing, Baidu, …) scrape public result pages, so there is nothing to sign up for. Enable browser fetching (
fetcher.browser.enabled: true, requires Playwright) and Google works without a key too. Brave / Google API keys are picked up automatically when present for extra reliability - Any model, any client: plain MCP — works with Claude Code, DeepSeek Harness, Cursor, VS Code, Cline and any other MCP-capable client
- More than search:
fetch_pagereads web pages and PDFs (Markdown output, paginated for long documents),wechat_searchsearches WeChat Official Account articles — the "found it, now read it" half - Works behind restrictive networks: Chinese sources (Baidu, Sogou, 360, WeChat) work out of the box; when an engine is blocked or rate-limited the request falls back to the next one automatically
- Clean results: sponsored results injected by search engines are removed — see "Ad filtering" below
# Claude Code
claude mcp add prismsearch -- npx -y prismsearch
[!WARNING] Scraping engines fetch results from public web pages. You are responsible for complying with each search engine's and target site's terms of service, robots policies and local laws, and for keeping request rates reasonable. The learning/research recommendation is not an additional restriction on the Apache-2.0 license. This project is not affiliated with any search engine company. See the full Disclaimer at the end.
Features
- 9 Search Sources: Google, Bing, Baidu, Brave, DuckDuckGo, Yandex, Sogou, 360 Search, plus WeChat Official Account articles — with an extensible engine plugin system
- 5 MCP Tools:
web_search,image_search,fetch_page,wechat_search,list_engines - Dual Transport: stdio (local) and Streamable HTTP (remote) MCP transport
- Smart Engine Selection: Auto-selects the best engine based on availability, latency, success rate, and language matching, with cross-engine fallback
- Google Triple Strategy: Custom Search API → browser rendering → plain HTTP, with automatic fallback and sticky success memory
- Ad Filtering: Baidu promotions, Bing / Google / DuckDuckGo sponsored results and 360 / Sogou paid slots are dropped and don't eat into the requested count; anything that slips through is filtered again by its landing URL (paid-click tracking parameters)
- Web Page Fetching: Fetch and extract content from URLs in HTML, plain text, or Markdown; optional Playwright rendering for JS-heavy pages
- Image Search: Multi-engine image search with size/type filters and optional base64 thumbnails
- Caching: Configurable TTL and LRU eviction with pluggable backends —
cache.backend: sqlite | memory | redis(SQLite by default) - Security: SSRF protection, rate limiting, domain whitelist/blacklist, optional Bearer auth for remote mode
- Hot Reload: Configuration file watching with automatic reload
- Flexible Config: YAML/JSON/TOML configuration with environment variable overrides
Example
A single web_search call returns structured, deduplicated results:
{
"results": [
{
"title": "Model Context Protocol - Introduction",
"url": "https://modelcontextprotocol.io/introduction",
"snippet": "The Model Context Protocol (MCP) is an open protocol that enables seamless integration between LLM applications and external data sources and tools.",
"source": "brave",
"position": 1
}
],
"totalResults": 10,
"engine": "brave",
"searchTime": 842,
"cached": false,
"page": 1,
"hasMore": true
}
Every item in results[] always has title, url, snippet, source (the engine) and position, and may have timestamp; with mode=aggregate items also carry sources and the response carries engines. When the engine ignored some parameters the response carries warnings. The same JSON is returned both as structuredContent and as text in content.
Architecture
flowchart LR
Client["MCP client<br/>Claude Code / Cursor / …"]
subgraph Transport["Transport src/server"]
Stdio["stdio"]
Http["Streamable HTTP<br/>auth · Host/Origin check · rate limit"]
end
subgraph Tools["Tools src/tools"]
WS["web_search"]
IS["image_search"]
WX["wechat_search"]
FP["fetch_page"]
LE["list_engines"]
end
subgraph Search["Search orchestration"]
Sel["Engine selection / circuit breaker<br/>engine-selector"]
Chain["Fallback chain · aggregate RRF<br/>dedup · ad filter"]
end
Engines["Engine adapters src/engines<br/>Google · Bing · Brave · Baidu · DDG<br/>Yandex · Sogou · 360 · Sogou WeChat"]
Cache[("Cache src/cache<br/>sqlite / memory / redis")]
subgraph Fetch["Fetching src/fetcher"]
SSRF["SSRF guard<br/>src/security/ssrf-guard"]
HF["HTTP fetcher"]
BF["Browser fetcher<br/>Playwright"]
WK["Remote workers<br/>ts-worker / py-worker"]
EX["Content extraction<br/>Readability / PDF"]
end
Client --> Stdio & Http
Stdio & Http --> Tools
WS & IS --> Sel --> Chain --> Engines
WX --> Engines
LE -. status .-> Sel
WS & IS & WX & FP -. read/write .-> Cache
FP --> SSRF --> HF & BF & WK
HF & BF & WK --> EX
In stdio mode there is a single client, so rate limiting happens at the tool layer; in HTTP mode the transport rate-limits per client. Whether fetch_page is delegated to a worker is controlled by workers.useFor; when no worker is available it falls back to the local fetchers, and the final URL returned by a worker is SSRF-checked again.
Requirements
- Node.js ≥ 22.19
- Native module
better-sqlite3ships prebuilt binaries for mainstream platforms (Windows/macOS/Linux, x64/arm64); if prebuilds are unavailable on your platform, a C++ build toolchain is required - Optional: Playwright for browser rendering. It is an
optionalDependency— installed by default (browsers download on install); usenpm install --omit=optionalfor a minimal install. To add it later:npm install playwright && npx playwright install chromium
Quick Start
Installation
npm install prismsearch
Usage with Claude Code
claude mcp add prismsearch -- npx -y prismsearch
Or add to your MCP settings:
{
"mcpServers": {
"prismsearch": {
"command": "npx",
"args": ["-y", "prismsearch"],
"env": { "BRAVE_API_KEY": "optional" }
}
}
}
Other clients
| Client | Config location | Notes |
|---|---|---|
| Claude Desktop | claude_desktop_config.json |
Same mcpServers snippet |
| Cursor | ~/.cursor/mcp.json or .cursor/mcp.json |
Same mcpServers snippet |
| VS Code (Copilot) | .vscode/mcp.json |
Top-level key is servers; add "type": "stdio" |
| Windsurf / Cline etc. | Their own MCP config | Generic command + args form |
| Remote (HTTP) | Any Streamable HTTP client | URL http://host:3000/mcp, header Authorization: Bearer <token> |
On Windows, if the client cannot find npx, set command to "cmd" and args to ["/c", "npx", "-y", "prismsearch"].
Use as an Agent Skill
skills/prismsearch/SKILL.md is an Agent Skill that teaches the agent when to use each tool: search first and then read the source pages, use timeRange / aggregate mode, fall back to browser rendering, page through long documents, and handle engine failures. The MCP server above still has to be connected; the skill only adds usage guidance.
To install it for Claude Code, copy the folder into your skills directory:
# All projects
cp -r skills/prismsearch ~/.claude/skills/
# Current project only
cp -r skills/prismsearch .claude/skills/
Other agents that support the Agent Skills format can load the same folder.
Use in DeepSeek Harness
dsh-plugin-prismsearch is a DeepSeek Harness plugin that installs both the MCP server and the skill in one step. In the DSH Web GUI, open Plugins → Add plugin and enter:
dsh-plugin-prismsearch
The plugin starts a pinned prismsearch version through npx, so Node.js >=22.19.0 must be on PATH. The first start downloads the package and can take a few seconds. Tools appear as mcp__prismsearch__web_search and so on. If BRAVE_API_KEY, GOOGLE_API_KEY or GOOGLE_CSE_ID are set where DSH starts, they are forwarded to the server. If you have already added an MCP entry with serverName: prismsearch by hand, remove it or rename it first, otherwise the two entries conflict. See the plugin README for details.
Engine capabilities
| Engine | Web | Image | Method | Default | Notes |
|---|---|---|---|---|---|
| ✅ | ✅ | API / browser / HTTP | on | Custom Search API is the most reliable; plain HTTP usually hits the JS wall | |
| Bing | ✅ | ✅ | HTTP scraping | on | |
| Brave | ✅ | ✅ | Official API | on | Needs BRAVE_API_KEY; skipped when absent |
| Baidu | ✅ | ✅ | HTTP scraping / JSON API | on | Chinese content |
| DuckDuckGo | ✅ | — | HTTP scraping | off | Frequent requests trigger a bot challenge |
| Yandex | ✅ | — | HTTP scraping | off | |
| Sogou | ✅ | — | HTTP scraping | off | Chinese content |
| 360 Search | ✅ | — | HTTP scraping | off | Chinese content |
Parameter support per engine (web search)
How each web_search parameter is translated for each engine. "—" means the engine has no equivalent; the parameter is accepted but ignored, and the response's warnings lists which parameters were dropped. list_engines also declares per-engine support in its capabilities field.
| Engine | region |
language |
safeSearch |
timeRange |
page |
count |
|---|---|---|---|---|---|---|
| Google (scrape) | gl |
hl |
safe=active |
tbs=qdr:d/w/m/y |
start offset |
num |
| Google (Custom Search API) | gl |
hl |
safe=active/off |
dateRestrict |
start offset, max 100 results total |
10 per request; larger counts fetch several pages |
| Bing | cc (country, uk → GB) + mkt (market) |
setlang |
adlt=strict |
filters=ex1:"ez1/ez2/ez3", custom range for year |
first offset (advanced by results actually returned) |
~10 per page; larger counts stitch several pages |
| Brave | country (uk → GB) |
search_lang |
safesearch=strict/moderate |
freshness=pd/pw/pm/py |
offset, max 10 pages |
up to 20 per request; larger counts fetch several pages |
| Baidu | — | — | — | gpc=stf=… (time range) |
pn offset |
rn |
| DuckDuckGo | kl (region + language, e.g. us-en) |
used for kl / Accept-Language |
kp=1 |
df=d/w/m/y |
s offset |
truncated client-side |
| Yandex | lr (region ID) |
lang |
— | — | p (0-based) |
numdoc |
| Sogou | — | — | — | s_from=inttime_* |
page |
fixed 10 per page, truncated client-side |
| 360 Search | — | — | — | adv_t=d/w/m/y |
pn |
fixed 10 per page, truncated client-side |
Image search: Google (gl / hl / safe, size and type via tbs), Bing (setlang, safesearch=strict, size and type via qft), Brave (country / search_lang / safesearch; the API has no paging, so pages are sliced from up to 200 results), Baidu (size via z, GIF via ic; no region / language / safe search).
On page 1 the server over-fetches a few extra results so that de-duplication still fills count; later pages of an auto-selected search stick to the engine that served page 1 so results don't jump between engines.
WeChat articles are a separate wechat config section (not a regular engine) served by the wechat_search tool; returned links expire.
Scraping engines depend on page structure and may break briefly when a search engine redesigns; the project runs a daily live smoke test to catch that early.
Usage with HTTP Transport
# Start with the bundled HTTP example config
npx prismsearch config/http.yaml
# Or use environment variables
PRISMSEARCH_SERVER_TRANSPORT=http PRISMSEARCH_SERVER_PORT=3000 npx prismsearch
The HTTP endpoint is http://127.0.0.1:3000/mcp (health check at /health). When exposing it beyond localhost, always enable auth: set PRISMSEARCH_AUTH_TOKENS or enable security.auth in your config.
CLI
prismsearch [config-file] # start the server; the optional positional argument is a config file (YAML / JSON / TOML)
prismsearch --help # bilingual (English / Chinese) help including common environment variables (-h)
prismsearch --version # print the version (-v)
The positional argument has the highest priority, above PRISMSEARCH_CONFIG and the default search paths (see "Configuration"). If the given file does not exist, the server exits with an error. Transport, port, etc. are not CLI flags — set them in the config file or via environment variables (see "Environment variables"). The CLI is intentionally a thin launcher: it does not provide a browser UI, hosted search account, or separate web dashboard; use an MCP-capable client (or the HTTP transport) to call the tools.
The npm package ships only this CLI / MCP server; it is not a JavaScript library. Do not import 'prismsearch' or deep-import files under dist/ — importing the entry point starts a server, and internal modules may change in any release. The stable, versioned interfaces are the MCP tool schemas, the configuration file, and the Worker protocol; to extend fetching, implement a Worker, and to add engines, contribute upstream or fork.
Privacy and local data
PrismSearch does not provide a hosted data service. In the default local stdio setup, requests and responses pass through the local process; cache entries are stored locally (SQLite by default) and logs go to the local process' stderr. If you enable remote HTTP transport, third-party API keys, browser fetching, proxies, Redis, or Workers, query text, URLs, headers, and fetched content may be sent to those providers or services. Review their privacy policies and configure retention, access controls, and log.redact for your deployment. Do not submit passwords, private tokens, personal data, or confidential content unless you have verified every service in the path.
Terms, copyright, and service access
Search snippets, images, pages, PDFs, and WeChat articles are supplied by third parties and may be protected by copyright or other rights. PrismSearch does not grant rights to copy, store, display, scrape, or redistribute third-party content. You are responsible for permission, attribution, robots directives, applicable law, and each provider's terms and rate limits. The Apache-2.0 license covers this repository's code only; it does not grant access to any search service, bypass authentication or anti-bot controls, or license third-party trademarks/content.
MCP Tools
web_search
Search the web using multiple search engines (Google, Bing, Baidu, 360, Sogou, DuckDuckGo, Yandex, Brave).
Parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| query | string | Yes | - | Search keywords, 1-500 characters after trimming |
| engine | string | No | auto | Engine: google, bing, baidu, so, sogou, duckduckgo, yandex, brave; auto-selected with fallback when omitted |
| region | string | No | - | Region code (e.g., cn, us, hk), max 10 characters |
| language | string | No | - | Language code (e.g., zh-CN, en), max 20 characters |
| count | integer | No | 10 | Number of results, 1-50 |
| page | integer | No | 1 | Page number, 1-10 |
| safeSearch | boolean | No | false | Enable safe search |
| timeRange | string | No | - | Time filter: day, week, month, year; auto-selection prefers engines that support it |
| mode | string | No | fallback | fallback: one engine, falling back on failure; aggregate: query the top 3 available engines concurrently and merge with Reciprocal Rank Fusion (deduplicated, results carry sources, response carries engines) |
When the client passes _meta.progressToken, the server sends notifications/progress each time an engine is tried / started.
image_search
Search for images using multiple search engines (Google, Bing, Baidu, Brave).
Parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| query | string | Yes | - | Search keywords, 1-500 characters after trimming |
| engine | string | No | auto | Image-capable engine: google, bing, brave, baidu; auto-selected with fallback when omitted |
| region | string | No | - | Region code, max 10 characters |
| language | string | No | - | Language code, max 20 characters |
| count | integer | No | 10 | Number of results, 1-50 |
| page | integer | No | 1 | Page number, 1-10 |
| safeSearch | boolean | No | false | Enable safe search |
| imageSize | string | No | - | Filter by size: small, medium, large |
| imageType | string | No | - | Filter by type: photo, clipart, gif, transparent |
| includeThumbnails | boolean | No | false | Inline base64 thumbnails in results (max 20, 50KB each) |
Each result has title, imageUrl, thumbnailUrl, sourceUrl, position and source, and may have sourceTitle, width, height and thumbnailBase64; the response also carries engine, searchTime, cached, page and hasMore.
fetch_page
Fetch and extract content from a webpage URL.
Parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| url | string | Yes | - | URL to fetch, http/https only, max 4096 characters |
| format | string | No | markdown | Output format: html, text, markdown |
| timeout | integer | No | 30000 (fetcher.timeout) |
Total timeout in milliseconds, 1000-120000, shared by all fallback / re-fetch attempts |
| method | string | No | http (fetcher.defaultMethod) |
Fetch method: http or browser (Playwright, for JS-rendered pages). When omitted, an http result that looks like a JS skeleton or anti-bot challenge page is re-fetched with the browser (if available). Explicit http never upgrades; browser falls back to http with a warning when Playwright is unavailable |
| waitForSelector | string | No | - | Browser only: CSS selector to wait for before extracting, max 500 characters; if it never appears, the content rendered so far is returned |
| maxLength | integer | No | 20000 | Max characters of content returned per call, 100-1000000; when exceeded the result has truncated: true and nextStartIndex |
| startIndex | integer | No | 0 | Character offset to start from (≥ 0); use nextStartIndex to read the rest (served from the same cache entry, no re-fetch) |
totalLength is the full content length; bodyTruncated means the response body exceeded fetcher.maxBytes and only its beginning was fetched. With format=html the HTML is returned once, in content.
Main-content extraction uses Mozilla Readability first (@mozilla/readability + linkedom) and falls back to the built-in heuristics. PDFs have their text layer extracted (unpdf, first 50 pages); scanned PDFs without a text layer produce a warning. Every target URL is checked by the SSRF guard first (see "Security").
wechat_search
Search WeChat Official Account (微信公众号) articles via Sogou WeChat search. Returns article titles, account names, publish dates, snippets, and signed temporary article URLs.
Notes:
- Article URLs are signed and time-limited (typically valid for a few hours) — use
fetch_pagepromptly to retrieve full content. - Results are cached for 10 minutes only (shorter than web search, due to URL expiry).
- Sogou applies rate limiting; the engine automatically rotates cookies and retries with backoff.
Parameters:
| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| query | string | Yes | - | Search keywords (Chinese works best), 1-200 characters after trimming |
| count | integer | No | 10 | Number of results, 1-10 |
| page | integer | No | 1 | Page number, 1-10 |
list_engines
List all registered search engines and their current status, including availability, latency, and supported features. No parameters.
PrismSearch MCP questions
How do I add PrismSearch MCP to Claude Code?
Run claude mcp add --env 'BRAVE_API_KEY=<YOUR_BRAVE_API_KEY>' --env 'GOOGLE_API_KEY=<YOUR_GOOGLE_API_KEY>' prismsearch -- npx -y prismsearch in your terminal. Add --scope user to make it available in every project.
How do I add PrismSearch MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Can PrismSearch read PDF files?
Yes, the fetch_page tool can read web pages and PDFs, providing Markdown output.
Does it filter out advertisements?
Yes, the server removes sponsored results from search engines and filters landing URLs to drop paid-click tracking parameters.