dsh-bing-search
Provides web search using DuckDuckGo as the primary engine, with automatic fallback to Bing when DuckDuckGo is unreachable or rate-limited, and includes tools to open and find content within web pages.
Click on "Install 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., "@dsh-bing-searchSearch the web for the latest updates on DeepSeek"
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.
dsh-bing-search
Web search for DeepSeek Harness (DSH), implemented as a small MCP server and powered by curl_cffi.
search order:
Probe DuckDuckGo HTML (
html.duckduckgo.com) and cache reachability for about 60 seconds. From mainland China this probe often fails unless a proxy is configured.Use DDG when it is reachable.
Fall back to Bing when DDG is down, rate-limited (HTTP 202 / challenge), or the result set is
quality_label=poor.Route Bing by language: Chinese /
zh-*markets go tocn.bing.com, otherwisewww.bing.com.
Every search response includes quality_score (0–1) and quality_label (good / weak / poor). Treat poor as unusable (dictionary pages, first-token junk). Do not cite those titles.
It gives a DSH agent four browser-style tools:
mcp__web__search— search the public web and return normalized organic results.mcp__web__search_images— search image indexes and rank results with explainable text scores (see docs/search_images.md).mcp__web__open— open a public web page and extract readable text.mcp__web__find— find text inside a long page and return nearby context.
DSH agent
-> @deepseek-ai/dsh-mcp-client
-> dsh-bing-search (MCP/stdio)
-> curl_cffi.AsyncSession(impersonate="chrome")
-> html.duckduckgo.com (if reachable)
-> else cn.bing.com / www.bing.comMainland China: DuckDuckGo is often unreachable without a proxy or VPN. That is expected. The plugin then uses Bing and sets warnings to duckduckgo_unreachable. The MCP child does not inherit your shell HTTP_PROXY / HTTPS_PROXY (trust_env=False). To force a proxy, set DSH_WEB_PROXY on the plugin process (for example http://127.0.0.1:10808 in the cordis env: map). Do not assume DDG will work on a typical mainland home or campus network.
Community plugin: DeepSeek Harness asks third-party plugins to use the
dsh-pluginGitHub topic for discovery.
Fastest install: give this repo to an agent
If your coding agent has terminal and filesystem access (Codex, Claude Code, Pi, OpenCode, etc.), paste this:
Install this DeepSeek Harness plugin into my current DSH setup:
https://github.com/Biogod2020/dsh-bing-search
Read the repository README and INSTALL.md first. Install it with uv, detect my active
DSH profile, add it through cordis.patch.yml using the required `insert` patch form,
preserve all unrelated config, use the absolute path of the installed dsh-bing-search
executable, then verify that mcp__web__search, mcp__web__open, and mcp__web__find are
registered. Finally run one real web search smoke test and report what changed.That is the recommended path. INSTALL.md contains a deterministic install contract written for agents.
Related MCP server: webmcp
Manual install
1. Install the executable
Python 3.10+ is required. With uv:
uv tool install --force git+https://github.com/Biogod2020/dsh-bing-search.gitFind the tool bin directory:
uv tool dir --binUse the absolute path to dsh-bing-search (or dsh-bing-search.exe on Windows) in the DSH config below.
For development instead of a tool install:
git clone https://github.com/Biogod2020/dsh-bing-search.git
cd dsh-bing-search
uv sync --extra devThe repository includes uv.lock for reproducible development installs.
2. Add it to DSH
DSH profiles combine a root cordis.yml with a patch layer cordis.patch.yml. When adding a new plugin through the patch layer, the entry must be wrapped in insert:
- insert:
- id: mcp-web
name: '@deepseek-ai/dsh-mcp-client'
config:
serverName: web
transport: stdio
command: /ABSOLUTE/PATH/TO/dsh-bing-search
args: []
toolCallTimeoutMs: 30000
failOnStartupError: true
reconnect:
enabled: true
initialDelayMs: 500
maxDelayMs: 30000
maxAttempts: 10Do not add a bare - id: mcp-web entry to cordis.patch.yml: bare entries patch existing IDs and an unknown ID can be skipped. If you are editing the root cordis.yml directly, a normal bare plugin entry is correct. See cordis.example.yml.
3. Verify
After DSH reloads the profile, the model should see:
mcp__web__search
mcp__web__search_images
mcp__web__open
mcp__web__findThen ask the agent to search for something current and open one result. A successful round trip verifies both search access and MCP registration. Recycle the MCP child after changing Python; the stdio process does not hot-reload. The optional native dsh-image-audit plugin (search_and_audit_images) is a separate Cordis insert — see dsh-image-audit/README.md.
Tools
search
{
"query": "DeepSeek Harness GitHub",
"count": 8,
"offset": 0,
"market": "en-US",
"safe_search": "Moderate"
}Returns:
Field | Meaning |
|
|
| Organic result |
| Stable ID from the canonical URL |
| 0–1 overlap of the query with titles/snippets |
|
|
| Fallback reason and quality notes |
Use market=zh-CN for Chinese queries. If the query contains CJK, Bing fallback still uses cn.bing.com even when market is en-US.
DuckDuckGo /l/?uddg= and Bing /ck/a redirects are decoded where possible. Common tracking parameters are stripped and duplicate URLs are merged.
For people, papers, or illustrated blogs, search the author name or a short proper noun first. If quality_label is poor, do not keep lengthening the query. Chinese academic metadata belongs in a specialized corpus (for example CNKI), not this general web search.
open
{
"url": "https://example.com/article",
"max_chars": 24000
}Fetches public HTTP(S) pages with curl_cffi, applies DNS/IP checks and safe redirects, limits response size, and extracts readable text without executing JavaScript.
open is built for article-like HTML. It is not a browser. Live DSH runs showed that weather and other widget-heavy sites (tianqi.com, weather.com.cn, and similar) often yield navigation chrome or near-empty text: Trafilatura finds no main article, then the fallback dumps the whole DOM. status can still be ok. For those pages, trust the search snippet, or open a simpler article URL. Do not expect live temperature, maps, or other JS-rendered UI.
find
{
"url": "https://example.com/article",
"pattern": "DeepSeek",
"max_matches": 5,
"context_chars": 700
}Returns matching regions without injecting the entire page into the model context.
Why three tools instead of one giant search_and_summarize tool?
The plugin keeps retrieval deterministic and lets the DSH model control the research loop:
search -> inspect candidates -> open -> find / search again -> synthesizeThe plugin handles HTTP, parsing, cleaning, caching, engine fallback, provenance, and a quality mark. The agent decides what to search, which sources to trust, when to reformulate the query, and when enough evidence has been collected. The agent must read quality_label and warnings.
Configuration
Environment variable | Default | Purpose |
|
| Override Bing HTML endpoint only when set to a non-default value (tests). Otherwise the host is chosen by language |
|
|
|
| empty | HTTP/HTTPS/SOCKS proxy. The process uses |
|
| Transfer timeout |
|
| Connect timeout |
|
| Maximum body size for |
|
| Maximum search-page body size |
|
| Maximum redirects |
|
| Maximum in-process concurrent requests |
|
| Search cache TTL |
|
| Page cache TTL |
Tests
Offline tests (parsers, quality score, locale routing, DDG-first / Bing fallback):
uv run pytest -m "not live"Live smoke test:
RUN_LIVE_BING=1 uv run pytest -m live -sThe marker name is still live / RUN_LIVE_BING. A live run hits DDG first and only uses Bing if DDG is unavailable.
CI covers Python 3.10, 3.12, 3.13 and 3.14.
Design and safety notes
This is an unofficial DuckDuckGo HTML + Bing HTML adapter. It does not use the retired Bing Search API.
DDG markup lives in
src/dsh_bing_search/providers/ddg.py.Bing markup lives in
src/dsh_bing_search/providers/bing_parser.py.Quality scoring lives in
src/dsh_bing_search/quality.pyand is engine-agnostic.Requests use
curl_cffi.AsyncSessionwith browser impersonation.User-supplied page URLs are restricted to public HTTP(S) targets and safe redirect handling is enabled.
Response bodies are size-limited.
CAPTCHA / challenge / HTTP 202 pages are reported as
status="blocked"; the plugin does not attempt to bypass them.Headless Bing on
www.bing.comoften returns structurally valid but unrelated cards.cn.bing.comhelps some hot Chinese queries; long-tail names and titles can still collapse to the first token. That is what the quality mark is for.opendoes not automatically retry slow target sites; increase the timeout environment variables if needed.
Community
DeepSeek Harness is currently in developer preview, so plugin interfaces may still evolve. For DSH-specific support and discovery:
Browse the
dsh-plugintopic.See the DeepSeek Harness repository.
Join the DSH community channels linked from the official repository.
Contributions and parser fixes are welcome.
License
MIT
Available Tools
4 toolsfindFind in Web PageA
Find a literal phrase in a page and return compact context windows around matches.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| pattern | Yes | ||
| max_matches | No | ||
| context_chars | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| error | No | |
| status | Yes | |
| matches | No | |
| pattern | Yes | |
| source_id | No | |
| total_matches | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It does reveal key behavior: matching is literal rather than regex or semantic, and the response consists of compact context windows around matches. However, it does not mention case sensitivity, failure modes, page loading behavior, or limits, leaving notable gaps.
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?
A single sentence contains the core action, the matching mode, and the response shape with no redundant words. It is front-loaded and easy to parse.
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?
The description is adequate for a simple tool, and the output schema likely covers return values. But with no annotations and no parameter documentation, it lacks details about max_matches behavior, exact context window semantics, and when to prefer sibling tools. It is minimally sufficient but not fully 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?
Schema description coverage is 0%, so the description must compensate. It clarifies that 'pattern' is a literal phrase and 'context_chars' relates to compact context windows, but it does not explain 'max_matches', 'url', defaults, or the exact relationship between parameters and output. This is only partial compensation for the missing schema descriptions.
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: finding a literal phrase in a page and returning compact context windows around matches. The word 'literal' helps distinguish it from the sibling 'search' tool, which implies broader or semantic search. This is a clear, specific purpose statement.
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 implies usage: use this tool when an exact literal phrase is needed within a page. However, it does not explicitly say when not to use it or mention alternatives like 'search' or 'search_images'. The usage guidance is present only by implication.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
openOpen Web PageA
Fetch a public HTTP(S) page with curl_cffi and return cleaned readable text.
Use after search when result snippets are insufficient. Private/local addresses are rejected, redirect targets use curl_cffi safe-follow mode, and response bytes are capped.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | ||
| max_chars | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| text | No | |
| error | No | |
| title | No | |
| status | Yes | |
| final_url | No | |
| source_id | No | |
| truncated | No | |
| elapsed_ms | No | |
| content_type | No | |
| fetched_bytes | No | |
| requested_url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden and discloses several useful traits: public-only access, rejection of private/local addresses, safe-follow redirect mode, and a response byte cap. It could also mention error behavior or timeout handling, but the provided constraints are substantial.
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?
Two tight sentences front-load the purpose, then add usage context and behavioral constraints. No filler, every sentence earns its place.
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?
The tool is simple and the description covers URL type, output format, redirect behavior, and a cap. The main gap is max_chars semantics, which matters because there is no schema-level documentation and no annotations.
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%, so the description must compensate. It adds that URL must be public HTTP(S), but it never explains the max_chars parameter or how the response cap relates to it. An agent cannot confidently tune max_chars based on this text.
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?
States a specific verb ('Fetch'), resource ('public HTTP(S) page'), and output ('cleaned readable text'). This distinguishes it from siblings like search and search_images: it retrieves page content rather than result snippets or images.
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?
Explicitly says 'Use after search when result snippets are insufficient,' giving a clear trigger condition and relationship to the primary sibling. It also states a when-not: private/local addresses are rejected.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchSearch the WebA
Search the public web. DuckDuckGo is tried first when reachable; Bing is the fallback.
Chinese queries / zh-* markets use cn.bing.com. Read quality_label: poor means the titles are unrelated or first-token junk — do not treat them as answers.
Args: query: Compact concrete nouns plus the qualifier that uniquely identifies the subject. "复旦光华楼" is better than "光华楼" — the extra place/institution is necessary, not padding. Do not write whole sentences. If a compact query is still ambiguous or hits the wrong entity, write more (place, institution, year, type). For a person plus a paper, search the author name first. count: Number of organic results to return, from 1 to 20. offset: Result offset for pagination, from 0 to 100. market: Locale such as en-US or zh-CN. Chinese text should use zh-CN. safe_search: SafeSearch level (used when Bing is the engine).
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | ||
| query | Yes | ||
| market | No | en-US | |
| offset | No | ||
| safe_search | No | Moderate |
Output Schema
| Name | Required | Description |
|---|---|---|
| error | No | |
| query | Yes | |
| market | No | |
| offset | No | |
| status | Yes | |
| results | No | |
| provider | No | |
| warnings | No | |
| elapsed_ms | No | |
| safe_search | No | |
| quality_label | No | good / weak / poor. If poor, do not treat results as answers. |
| quality_score | No | 0-1 overlap of the query with titles/snippets. Below 0.3 is not trustworthy. |
| returned_count | No | |
| requested_count | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden and handles it well: it discloses the DuckDuckGo/Bing fallback order, the cn.bing.com behavior for Chinese markets, and the meaning of quality_label=poor. This gives agents useful execution expectations beyond what the schema could convey.
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 longer than average, but the length is justified by the need to explain query construction and engine quirks. The opening behavior is front-loaded, and the Args section is clearly organized. A small amount of redundancy exists, but every major sentence adds practical value.
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 the output schema exists and annotations are absent, the description covers the key operational context: engine fallback, locale behavior, quality_label handling, and parameter semantics. It lacks explicit when-to-use versus search_images/open/find guidance, but the other information is sufficient for an agent to call and interpret results correctly.
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%, so the description must compensate, and it does thoroughly. Each parameter is explained: query receives detailed formulation rules, count is bounded to 1–20, offset to 0–100, market is tied to locale, and safe_search enum values are named. This is far more helpful than the bare schema.
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 first sentence clearly states the action and scope: 'Search the public web.' The description goes beyond the title by specifying engine behavior (DuckDuckGo first, Bing fallback) and the Chinese-market variant, which distinguishes this tool from image or document navigation 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 provides strong guidance on how to construct queries, including concrete examples and disambiguation advice (e.g., '复旦光华楼' is better than '光华楼'). It also warns when not to trust results via quality_label. It does not explicitly name alternative tools like search_images, so some sibling differentiation is left implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_imagesSearch ImagesA
Search image indexes and rank results with pure text so vision is not required.
auto (default) tries Bing Images first and falls back to Wikimedia Commons
when the top text score is below ~40, so one call yields a ranked set.
bing_images parses Bing Images metadata (original URL / thumbnail / source
page / title). commons queries Wikimedia Commons, a curated and
licence-clear platform. Every result carries a 0-100 text score, a domain
hint and explainable signals; pick the highest score, treat scores below
~40 as unverified, and optionally verify with find/open on the source
page before downloading.
Args: query: What the image should depict. Compact concrete nouns plus the qualifier that uniquely identifies the subject (e.g. "复旦光华楼", "台州城墙"). "复旦光华楼" is better than "光华楼". Do not write whole sentences. If a compact query is still ambiguous or hits the wrong entity, write more (place, institution, year, type). count: Number of ranked image results to return, from 1 to 20. market: Locale such as en-US or zh-CN (Bing Images; Commons is language-neutral). provider: auto (default), bing_images, or commons.
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | ||
| query | Yes | ||
| market | No | en-US | |
| provider | No | auto |
Output Schema
| Name | Required | Description |
|---|---|---|
| error | No | |
| query | Yes | |
| market | No | |
| status | Yes | |
| results | No | |
| provider | No | |
| warnings | No | |
| elapsed_ms | No | |
| returned_count | No | |
| requested_count | 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 it does so thoroughly. It discloses the ranking mechanism, the auto fallback threshold, what each provider does, and the exact result signals: 0-100 text score, domain hint, and explainable signals. It even tells the agent how to assess confidence and when verification is needed, which goes well beyond a minimal tool description.
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 front-loaded with purpose and behavior, and the Args section is logically organized. It is longer than typical descriptions, but that length is justified by the zero-coverage schema and the need to explain provider behavior and scoring. Minor redundancy exists because provider defaults and enum values are repeated from the schema, but the added context still earns its place.
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 the tool's provider-switching complexity, fallback threshold, scoring semantics, and four parameters, the description provides everything needed to select and invoke it correctly. It explains query formulation, ranking confidence, provider differences, and optional verification workflow. The output schema covers return structure, so the description does not need to detail the exact JSON response.
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%, so the description must fully compensate for the schema's lack of parameter documentation. It does: `query` has concrete examples and wording advice ('复旦光华楼' is better than '光华楼'), `count` is bounded 1-20, `market` is explained as locale-specific to Bing while Commons is language-neutral, and `provider` enumerates the options. This is excellent parameter documentation.
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: 'Search image indexes and rank results with pure text so vision is not required.' This clearly distinguishes the tool from the sibling `search`, `open`, and `find` by emphasizing image indexes and text-based ranking. The provider variants (bing_images, commons) further specify exactly what kind of image search this is.
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 usable routing guidance: `auto` is the default, it falls back to Commons below ~40 text score, and results below ~40 should be treated as unverified. It also recommends verifying with `find`/`open` before downloading, which indirectly differentiates this search tool from sibling file/URL tools. It lacks an explicit 'when not to use this tool' statement, but the behavioral and provider guidance is clear enough.
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. Dates show when Glama detected each change.
4 tool updates
v0.1.0- First observed
find - First observed
open - First observed
search - First observed
search_images
TDQS
Each tool targets a clearly distinct action: web search, image search, page retrieval, and in-page phrase matching. Search and search_images are separated by media type, while open and find both operate on pages but serve complementary pre- and post-retrieval needs, so an agent can select without confusion.
All tool names are short imperative verbs in snake_case: search, search_images, open, find. The only compound name, search_images, naturally follows a verb_noun pattern, and the overall naming is predictable and consistent.
Four tools form a tightly scoped search-and-browse toolset. Each tool earns its place: web search, image search, full-page reading, and targeted phrase lookup. The count is neither thin nor bloated for the server's stated purpose.
The server covers the full core workflow: discovering content via web or image search, opening pages when snippets are insufficient, and locating specific phrases within pages. Pagination, locale, safesearch, and provider fallback options also cover important search variations, leaving no obvious dead ends.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Docs: https://docs.keenable.ai/mcp-server Keenable is a free, remote MCP server that gives agents access to the web index. Search the web with ranked results and date/site filters, then fetch any indexed page as clean markdown. Works out of the box with no account or API key.
Serper MCP — wraps the Serper Google Search API (serper.dev)
Scrape, crawl and search the web for AI agents via MCP.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceThis MCP server provides tools for AI agents to search the web, fetch page content, and query specific elements from pages using DuckDuckGo.20-
- AlicenseNot gradedqualityCmaintenanceMCP server for web search and content extraction using DuckDuckGo or SearXNG, with Playwright-based fetching and LLM-powered data extraction.139MIT
- AlicenseAqualityCmaintenanceA general MCP server providing web search capabilities using DeepSeek's native online search API.16128MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for internet search via direct Google and DuckDuckGo HTML scraping with AI-powered result normalization and optional summarization, requiring no API keys for search.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Biogod2020/dsh-bing-search'
If you have feedback or need assistance with the MCP directory API, please join our Discord server