security-proxy MCP server
2026년 11월 12일 커밋프롬프트 인젝션을 방지하고, PII를 마스킹하며, 액세스 정책을 강제하는 MCP server용 투명 보안 게이트웨이 역할을 합니다.
다른 이름 GuardBee/guardbee-mcp, security-proxy-fa4790, @guardbee/mcp-security-proxy
- 스타
- 2
- Tools
- —
- 다운로드, 30일
- 6,120
- 최신 버전
- 1.39.0
- 마지막 커밋
- 2026년 11월 12일
- 라이선스
- MIT
security-proxy MCP란?
프롬프트 인젝션을 방지하고, PII를 마스킹하며, 액세스 정책을 강제하는 MCP server용 투명 보안 게이트웨이 역할을 합니다.
프로젝트 README에서 생성된 요약
security-proxy MCP server 정보
security-proxy는 Model Context Protocol (MCP) 환경을 다양한 보안 위협으로부터 보호하도록 설계된 투명 게이트웨이입니다. Claude Desktop 또는 Cursor와 같은 AI 클라이언트와 기존 MCP server 사이에 위치하여, 서버의 코드를 수정하지 않고도 방어 계층을 제공합니다. 클라이언트 설정을 수정하여 프록시 명령 뒤에 대상 서버를 실행하는 방식으로 로컬에서 사용합니다.
이 도구는 영어와 터키어 기반의 27개 규칙을 사용한 프롬프트 인젝션 탐지, IBAN, 신용카드, 여권 번호와 같은 민감한 데이터에 대한 PII 마스킹 등 여러 단계의 보호 기능을 제공합니다. 각 인터셉터에 대해 차단(block) 또는 경고(warn) 모드로 작동할 수 있습니다. 개발자는 게이트웨이 모드에서 단일 YAML 정책을 통해 여러 서버를 관리할 수 있으며, 이를 통해 도구 가시성, 액세스 정책 및 감사 로그를 중앙에서 제어할 수 있습니다. 또한 서로 다른 서버 세션 간의 데이터 유출을 방지하는 toxic-flow 차단 기능과 제공자 키 및 사용 예산을 관리하기 위한 LLM API 게이트웨이와 같은 특화된 기능도 포함되어 있습니다.
활용 사례
- 1프롬프트 인젝션 공격 방지AI 클라이언트가 프록시를 사용하여 프롬프트나 도구 결과에 포함된 악의적인 명령을 탐지하고 차단할 수 있습니다.
- 2민감한 개인정보 보호개발자는 전화번호나 연결 문자열과 같은 개인 데이터가 LLM에 도달하기 전에 마스킹되도록 보장할 수 있습니다.
- 3에이전트 활동 모니터링 및 감사보안 팀은 설정 가능한 감사 로그를 통해 모든 도구 호출 및 요청에 대한 기록을 유지할 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
security-proxy MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 security-proxy MCP 설치
$ claude mcp add security-proxy-fa4790 -- npx -y @guardbee/mcp-security-proxyCursor에 security-proxy MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"security-proxy-fa4790": {
"command": "npx",
"args": [
"-y",
"@guardbee/mcp-security-proxy"
]
}
}
}VS Code에 security-proxy MCP 설치
.vscode/mcp.json
{
"servers": {
"security-proxy-fa4790": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@guardbee/mcp-security-proxy"
]
}
}
}VS Code CLI에 security-proxy MCP 설치
$ code --add-mcp '{"name":"security-proxy-fa4790","type":"stdio","command":"npx","args":["-y","@guardbee/mcp-security-proxy"]}'Claude Desktop에 security-proxy MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"security-proxy-fa4790": {
"command": "npx",
"args": [
"-y",
"@guardbee/mcp-security-proxy"
]
}
}
}Codex에 security-proxy MCP 설치
$ codex mcp add security-proxy-fa4790 -- npx -y @guardbee/mcp-security-proxyCodex config.toml에 security-proxy MCP 설치
~/.codex/config.toml
[mcp_servers.security-proxy-fa4790] command = "npx" args = ["-y", "@guardbee/mcp-security-proxy"]
Gemini CLI에 security-proxy MCP 설치
$ gemini mcp add -s user security-proxy-fa4790 npx -- -y @guardbee/mcp-security-proxyGemini settings.json에 security-proxy MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"security-proxy-fa4790": {
"command": "npx",
"args": [
"-y",
"@guardbee/mcp-security-proxy"
]
}
}
}구성
OTEL_EXPORTER_OTLP_ENDPOINTOTEL_EXPORTER_OTLP_HEADERSOTEL_SERVICE_NAME
| 이름 | 설명 | 유형 |
|---|---|---|
| OTEL_EXPORTER_OTLP_ENDPOINT | — | |
| OTEL_EXPORTER_OTLP_HEADERS | — | |
| OTEL_SERVICE_NAME | — |
자동 검사
2026년 11월 13일에 실행됨전체 보고서 →아직 인증되지 않았습니다. 서버는 80점 이상의 점수, 심각한 결함 없음, 그리고 검사에 충분한 데이터를 갖추어야 합니다. 검사 방식 · 점수를 높이기 위해 수정할 항목
- 소스 저장소 연결 및 접근 가능guardbee/guardbee-mcp is public and reachablegithub.com/guardbee/guardbee-mcp ↗통과
- 패키지가 이 저장소를 소스로 명시@guardbee/mcp-security-proxy names guardbee/guardbee-mcp as sourcenpmjs.com/package/@guardbee/mcp-security-proxy ↗통과
- 빌드 출처(Sigstore 증명)Sigstore attestation for @guardbee/mcp-security-proxynpmjs.com/package/@guardbee/mcp-security-proxy/v/1.39.0#prov ↗통과
- 오픈 소스 라이선스 (OSI)MITspdx.org/licenses/MIT.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-12github.com/guardbee/guardbee-mcp ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음No popular package one edit away from @guardbee/mcp-security-proxy통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음75 resolved dependencies checked; no critical advisoryosv.dev ↗통과
- 모델에 대한 숨겨진 지침 없음Instruction aimed at the model found in the description or README결함 발견
- 파괴적인 도구에 라벨 표시됨검사되지 않음
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기@guardbee/mcp-security-proxy
🇬🇧 English | 🇹🇷 Türkçe | 🇨🇳 中文 | 🇯🇵 日本語 | 🇰🇷 한국어 | 🇧🇷 Português | 🇪🇸 Español | 🇩🇪 Deutsch
A transparent security layer that sits in front of any MCP server. Blocks prompt injection attacks, masks PII in responses, and writes every request to an immutable audit log.
Telemetry is off by default. With
GUARDBEE_TELEMETRY=1it sends the server, tool, success, duration and short parameter values such as a file path; longer strings and fields likecontent,tokenorpasswordare replaced with a placeholder. See@guardbee/mcp-telemetry.
Claude ──► MCP Security Proxy ──► Any MCP Server
│
├─ Prompt injection detection (27 rules, EN + TR)
├─ PII + secret masking (TC, VKN, IBAN, card, phone, 22 key formats)
├─ Block or warn mode
├─ Toxic-flow (lethal trifecta) blocking
└─ Hash-chained audit log
Features
- Prompt Injection Protection — 27 rules in English and Turkish; precise ones block, generic phrases only warn
- Tool-result injection — the same patterns applied to tool results, tagged MCP06:2025. Block mode replaces the result; warn mode prepends a warning
- Session tool pin — the first
tools/listis pinned. A later description or schema change is a rug pull (MCP03:2025). Block mode keeps serving the pinned definition and refuses the drifted call - PII Masking — TC Kimlik No, VKN, IBAN, card and phone numbers (checksum-validated), passport, SGK, MERSİS, date of birth, postal and KEP addresses, email, opt-in IP/MAC/plates, 22 provider key formats, private keys and connection strings are masked in responses
- Block / Warn Mode — each interceptor can independently run in blocking or warning mode
- Audit Log — configurable log written to console or a file
- Gateway mode — several MCP servers behind one proxy, one YAML policy (allow / deny / mask / warn)
- Toxic-flow blocking — tracks the lethal trifecta across servers and blocks the egress call that would complete it
- LLM API gateway — OpenAI- and Anthropic-compatible endpoints: gateway keys instead of provider keys, PII masking and injection checks on prompts, token and spend budgets, usage and cost in the audit log
- A2A gateway — Agent2Agent calls between agents go through the gateway: callers authenticate, injection in messages and artifacts is blocked, personal data is masked, push-notification webhooks into private networks are refused, and every call is audited
- Coding-agent hooks —
guardbee-hookapplies the same policy to Claude Code's and Cursor's own shell, file and web tools - Zero Code Changes — attaches in front of any existing MCP server
Quick Start
npm install -g @guardbee/mcp-security-proxy
Add to claude_desktop_config.json:
{
"mcpServers": {
"secure-filesystem": {
"command": "npx",
"args": [
"-y", "@guardbee/mcp-security-proxy",
"--", "npx", "-y",
"@modelcontextprotocol/server-filesystem", "/tmp"
]
}
}
}
The proxy launches whatever comes after
--as the target MCP server.
Gateway Mode: Several Servers, One Policy
Put every MCP server behind one proxy with a guardbee-proxy.yaml. init does the move for you:
npx -y @guardbee/mcp-security-proxy@^1 init --client claude-desktop # or cursor, claude-code, --file ./mcp.json
It moves each stdio server into ~/.guardbee/guardbee-proxy.yaml (mode 0600), backs up the client config and points it at the proxy. HTTP servers stay as they are and are reported, because they would bypass the policy. --dry-run prints both files without writing. Or by hand:
{
"mcpServers": {
"guardbee": {
"command": "npx",
"args": ["-y", "@guardbee/mcp-security-proxy@^1", "--config", "/path/to/guardbee-proxy.yaml"]
}
}
}
version: 1
upstreams:
github:
command: npx
args: ["-y", "@modelcontextprotocol/server-github"]
env: { GITHUB_PERSONAL_ACCESS_TOKEN: "${GITHUB_TOKEN}" } # read from the environment
postgres:
command: npx
args: ["-y", "@guardbee/mcp-db-gateway"]
labels: # override the heuristic labels
github__get_issue: [untrusted]
github__create_pull_request: [egress]
tools: # what the agent sees (globs on <upstream>__<tool>)
hide: ["*__delete_*"]
descriptions:
github__create_issue: "Create an issue in acme/* repositories only."
rules: # first match wins
- id: no-deletes
match: { tool: "postgres__delete_*" }
action: deny # allow | deny | mask | warn | approve
- match: { tool: "postgres__query", args: { table: "salaries" } } # dotted path → value, strings are globs
action: mask
mask: { fields: [salary, iban] } # blank these JSON keys
- match: { label: destructive }
action: approve # ask the person first
taint:
mode: strict # strict | approve | warn | off
basis: capability # capability | data — data: block only egress calls that carry sensitive data
interceptors:
anomaly: # off unless set; limits per session, sliding window
enabled: true
action: warn # warn | block
callBurst: { count: 60, windowSeconds: 60 }
audit:
sink: file
filePath: ./guardbee-audit.jsonl
-
Tools and prompts appear as
<upstream>__<tool>. -
Toxic flow (lethal trifecta): each tool is labeled
untrusted,sensitive,egressordestructive(name/description heuristics, overridable underlabels). Once a session has read untrusted content (anuntrustedtool or any resource) and sensitive data (asensitivetool or any PII in a result), anegresscall is blocked instrictmode and only logged inwarnmode. The check spans servers: an issue read from GitHub plus a customer record from a CRM blocks a webhook on a third server. -
Rules match on
tool(glob),upstream,label,session(clean|tainted) andargs.maskforces PII masking for that tool even when masking is off, andmask.fieldsalso blanks the named JSON keys in text andstructuredContent. A rule'sallowdoes not skip the toxic-flow check; relabel the tool instead. -
Topics (
topics,match.topic): a rule can name a subject instead of a tool — "nothing about mergers or salaries leaves through this agent". A topic is a list of terms; text is on topic whenminMatches(default 1) different terms appear. Matching folds case and Turkish letters (BİRLEŞME=birlesme), and a term may take a suffix (maaşfindsmaaşları,satın almafindssatın almayı); quote a term to match the whole word only ('"AI"'). The rule is checked on the call's arguments, and again on what comes back — the tool result, a resource, a prompt — so a subject that only shows up in the answer is caught too:denywithholds it,maskforces PII masking andmask.fields,warnlogs,approveasks (once: not again for the answer of a call it already approved). In the LLM API gateway topic rules apply to the whole prompt, withtool: llm:<model>;approverefuses there, since an API call has no one to ask.topics: - id: ma terms: [birleşme, "satın alma", "due diligence", acquisition, merger] - id: salary terms: [maaş, bordro, payroll, salary] minMatches: 1 rules: - { id: no-ma-out, match: { topic: ma, label: egress }, action: deny } - { id: contractors, match: { topic: salary, user: "*@contractor.com" }, action: approve } - { id: ma-to-llm, match: { topic: ma, tool: "llm:gpt-*" }, action: deny } -
Tool exposure (
tools):exposeis an allowlist of globs on the name the agent sees (absent: every tool), andhideremoves tools after it. A hidden tool is left out oftools/list, so the model never reads its description (a smaller poisoning surface and fewer tokens), and a call to it is refused and counts towardanomaly.repeatedBlocks.descriptionsreplaces a tool's description with one you wrote; drift detection keeps watching the server's own. Unlike adenyrule, which refuses at call time, hiding takes the tool out of the agent's view. -
Tool poisoning at
tools/list(interceptors.toolPoisoning, on by default): every definition is scanned before the agent sees it — the description (yours, when you wrote one undertools.descriptions), parameter descriptions and enum values in the input schema, and the read-only annotation. It catches instructions aimed at the model (<IMPORTANT>, "do not tell the user", "ignore previous instructions"), cross-tool shadowing ("when using the X tool, always…"), requests to read.ssh/.env, hidden zero-width, bidi and ANSI characters, words with Cyrillic or Greek lookalikes, and areadOnlyHintthat the description contradicts. Inblockmode (default; followspromptInjection.actionwhen unset) a tool with a critical or high finding is left out of the list and its calls are refused; medium findings (encoded blobs) only warn. Each finding is logged once asruleId: poisoning:<pattern>. The rules are the ones@guardbee/mcp-tool-poisoning-scanneruses, now shared through guard-core. -
Credentials leaving (
interceptors.egressSecrets, on by default): before anegresstool runs, the arguments it would actually receive are checked for credentials — provider keys (AWS, GitHub, OpenAI, Anthropic, Stripe, Slack, …), private keys and connection strings with a password; the same fixed-format rules PII masking uses, never the broad keyword ones. Data taint only knows what this session's tools returned; this also catches a key the model got from the prompt, a file or its own context.block(default; followspromptInjection.actionwhen unset) refuses the call,warnlogs it; the audit event has the credential masked either way. A PII token stays a token for an egress tool unlesspiiMasking.detokenizeForEgress, so only then is its value checked.allowToolsexempts tools by glob (a deploy tool that takes a DB URL, say). Personal data is left to PII masking and taint. -
Sampling (
interceptors.sampling, off by default): a server can ask the agent's model for a completion (sampling/createMessage) — and a malicious one can use that to smuggle instructions to the model or pull data out. Off, the proxy does not offer sampling to servers at all. On, a request is answered only while one of that server's tool calls is running, by the session that made the call (two sessions calling the same server at once: refused, since it could belong to either);includeContextis forced tonone, so a server never gets the conversation;maxTokensis capped (default 1024) and so is the number of requests per call (maxPerCall, default 3); the system prompt and messages get the injection scan;approval: trueasks the person first. The model's answer goes back to the server, so it is treated as egress: a credential or data this session saw blocks it, and personal data is masked. Events usetool: sampling:<upstream>andruleId: sampling:<check>. The capability is offered when the proxy starts, so turning it on or off needs a restart. -
Approval:
approve(a rule action, ortaint.mode: approvefor toxic flows) shows the person a yes/no form through MCP elicitation, with the tool, the reason and the arguments. Anything but an explicit yes — decline, cancel, no answer withinapproval.timeoutSeconds(default 120) — blocks the call. A client without elicitation support cannot approve, so the call is blocked with a message saying so. -
Approval in the dashboard: with
approval.channels: [elicitation, dashboard]andaudit.dashboardset, a client that cannot show a prompt no longer blocks the call outright. The request goes to the GuardBee dashboard (MCP Gateway page) with the arguments PII-masked, workspace owners and admins get a notification, and the proxy holds the call until someone approves or denies it there ortimeoutSecondspasses. Channels are tried in order; the first one that can ask gives the answer. -
Data-based taint (
taint.basis: data): the defaultcapabilitybasis blocks every egress call once a session holds untrusted and sensitive content. Withdata, the proxy keeps hashed fingerprints of what sensitive tools (and PII-bearing results) returned — personal data and credentials, id-like tokens, and runs of words — and treats an egress call as a toxic flow only when its arguments carry that data (12+ words in common, or an exact identifier; PII tokens count as their values) and the session also read untrusted content. The block message names the tool the data came from. Licence text, markdown boilerplate and text that also came back from ordinary results or from 3+ tools are ignored. Fingerprints are hashes, kept in memory per session. Trade-off: a paraphrase or a summary of the data is not caught; keepcapabilitywhere that matters. Incapabilitymode the same evidence is added to the block reason when found. -
Anomaly checks (
interceptors.anomaly): behaviour no single call shows, counted per session over a sliding window.callBurst— more than 60 tool calls in 60s (a loop, or a denial-of-wallet).sensitiveSweep— more than 25 different reads ofsensitivetools in 300s (enumerating a store record by record; re-reading the same record does not count).destructiveBurst— more than 5destructivecalls in 60s.repeatedBlocks— more than 5 calls blocked or declined in 300s (probing the policy; a client that cannot show an approval prompt does not count). Each takes{ count, windowSeconds }; the numbers above are the defaults.warnlogs the first trip of each check;blockrefuses calls over the limit until the window slides, and after repeated blocks refuses every later call in the session. Events arewarn/blockedwithruleId: anomaly:<check>, so the dashboard shows them without changes. Off unless configured. -
Quotas (
quotas): caps on tool calls over a fixed window, counted across sessions — whereinterceptors.anomalywatches one session, a quota holds when a user opens ten. Each entry hasmatch(toolanduserglobs,upstream,label,group; all optional),limit,windowSecondsandper:user(default; the OIDC user, or the session without one),session, orgateway(one budget for everyone, e.g. a paid upstream). Example:quotas: [{ id: exports, match: { label: egress, group: contractors }, limit: 20, windowSeconds: 3600 }]. Every matching quota is checked and a call counts against all of them or none; only calls that are about to reach the upstream count, so a call the policy refused does not spend quota. A full quota refuses the call with the time to retry, logsruleId: quota:<id>, and does not count towardanomaly.repeatedBlocks. Counters live in the proxy process: several replicas each keep their own. -
Policy from the dashboard:
policy: { source: dashboard, refreshSeconds: 60 }(withaudit.dashboard) takes labels, rules, taint, approval, defaults and interceptors from the workspace policy edited in the GuardBee dashboard, instead of this file. Upstreams, listen and audit stay local. The proxy fetches it at start and re-checks it with an ETag; an update applies to the next call in every session (labels from the nexttools/list). With no dashboard policy saved, the dashboard unreachable, or an invalid document, the proxy keeps the local or last good policy — it never runs without one. -
Documents (
interceptors.documents, off by default): images and blobs in tool results, embedded resources and resource reads — PDFs, screenshots, scanned pages — are read with@guardbee/mcp-document-scanner: the PDF text layer, and OCR for images and pages without text when the optionaltesseract.js(and@napi-rs/canvasfor scanned PDFs) are installed. A document holding personal data or a credential is replaced by a notice inblockmode (ruleId: documents:pii) or logged inwarnmode; its counts go intopiiHitsand taint the session like PII in text. A document that could not be read (OCR not installed, overmaxBytes) is logged asdocuments:unread.{ enabled: true, action: block, ocr: true, maxBytes: 26214400 }. -
Personal-data counts: tool responses and resource reads that contained PII carry
piiHits, a count per category (tc_kimlik,vkn,iban,credit_card,email,phone_tr; credentials assecret). Counts only, never the values, and counted even with masking off. The dashboard builds its KVKK report from them. -
Tokenize: with
interceptors.piiMasking.mode: tokenizethe model sees<pii:tc_kimlik:7f3a9b21>instead of the value and can still pass it to another tool: the proxy puts the real value back on the way to that server. Tokens live in memory for the session only, and are not turned back into values for anegresstool unlesspiiMasking.detokenizeForEgress: true. -
Prompts (
prompts/get) get the same injection scan and PII masking as tool results. -
interceptors.definitionDrift.recheck: on-changeskips the per-calltools/listand re-checks only after a server sendstools/list_changed, which the proxy also passes on to the agent. -
Build provenance (
provenance,warnby default): before a stdio upstream starts, the proxy resolves the packagenpx/pnpm dlx/bunxwould run and checks its npm provenance: a Sigstore-signed SLSA attestation (signature, certificate chain and transparency-log entry against the Sigstore trust root, fetched through TUF) whose statement names that exact tarball (sha512 = the registry'sintegrity), signed by a workflow of the repository it names, which must match the package'srepositoryfield. The command then runs pinned to the version that was checked (npx -y pkg→npx -y pkg@1.2.3), so a release published in between is not what starts.warnstarts unverified packages and logsruleId: provenance:unsigned | invalid | error | unsupported;requirerefuses them (per upstream:upstreams.<name>.provenance: off | warn | require). Results are cached per version in~/.guardbee/provenance.json(provenance.cacheFile); another tarball under a version verified before counts as tampering.provenance.offline: trueuses only the cache and the trust root on disk (pin exact versions for that). Check without starting anything:guardbee-proxy provenance --config <file>(exit code 1 when an upstream would be refused). PyPI (uvx,uv tool run): every file of the release must carry a PEP 740 attestation from its Trusted Publisher (signed by that repository's workflow, naming the file and its sha256), anduvx pkgruns asuvx pkg==<version>. Container images (docker run,podman run): the tag is resolved to a digest and the image's cosign keyless signature (sha256-<digest>.sig) is verified; the signer must be a workflow of the image owner's GitHub account forghcr.io/<owner>/…, or matchprovenance.signers("docker.io/acme/*": "https://github.com/acme/") elsewhere, and the command runs pinned toimage@sha256:….--format sarifwrites the findings as SARIF 2.1.0 for code scanning. Limits: many packages publish without provenance (they show asunsigned, as do images signed another way than cosign, such as Docker Hub'smcp/images); a private npm registry is used throughprovenance.registryornpm_config_registry, a PyPI mirror throughprovenance.pypiIndex(it needs the integrity API), and private images are not supported (anonymous registry tokens only); the single-server--form does not check.provenance: mode: warn # off | warn | require upstreams: github: command: npx args: ["-y", "@modelcontextprotocol/server-github"] provenance: require # this one must be verified to start -
Persistent tool pins (
interceptors.definitionDrift.persist, on by default in gateway mode): the definitions a server first listed (name, description, input/output schema, annotations) are pinned by SHA-256 in~/.guardbee/pins.json(pins.fileto move it; written atomically, mode 0600), so a server that rewrites a tool between two runs, after an update or a compromise, is not trusted again just because a new session started. On a change,onChange: approve(default) keeps showing the agent the approved definition and asks the person before the first call, with the old and new description side by side; once approved, the new definition is pinned.blockrefuses the call,warnlogs and uses the new one. A new tool on a known server is held the same way. Audit events (ruleId: pin:changed | pin:added | pin:removed) carry both hashes; the descriptions only withaudit.includePayloads. Manage them withguardbee-proxy pins list | approve <upstream> [tool] | reset [upstream] [tool], and seed them from CI withguardbee-proxy pins import <baseline.json> --upstream <name>(anmcp-rug-pull-detectorbaseline: same hashes). The single-server--form keeps per-session pins only. -
Audit log is hash-chained. By default it stores a SHA-256 of the arguments instead of the arguments, and no results; set
audit.includePayloads: trueto log them. Check a log withguardbee-proxy verify-audit ./guardbee-audit.jsonl. -
guardbee-proxy validate --config guardbee-proxy.yamlchecks a config without starting any server. -
Without
--config, the proxy also picks up./guardbee-proxy.yamlorGUARDBEE_PROXY_CONFIG=<file>.yaml.
The single-server -- form above keeps its 0.x behavior: tool names are not prefixed, payloads are logged, and a toxic flow is only logged as a warning.
security-proxy MCP 질문
security-proxy MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add security-proxy-fa4790 -- npx -y @guardbee/mcp-security-proxy를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
security-proxy MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
보안 프록시는 무엇으로부터 보호하나요?
프롬프트 인젝션 공격, 도구 결과 인젝션, 그리고 PII 또는 비밀 정보의 유출로부터 보호합니다.
기존 MCP server와 함께 사용할 수 있나요?
네, 코드 변경 없이 기존의 모든 MCP server 앞에 연결하여 사용할 수 있습니다.
게이트웨이 모드는 어떻게 작동하나요?
단일 YAML 정책을 사용하여 허용, 거부, 마스킹 또는 경고 설정을 통해 여러 MCP server를 하나의 프록시 뒤에서 관리할 수 있습니다.
텔레메트리가 기본적으로 활성화되어 있나요?
아니요, 텔레메트리는 기본적으로 비활성화되어 있습니다.