Trustabl MCP server
2026년 11월 15일 커밋결정론적 정적 분석을 사용하여 9가지 SDK에 걸친 AI agent 코드의 신뢰성 및 안전성 결함을 찾아내고 수정합니다.
다른 이름 trustabl/agent-reliability-analyzer, agent-reliability-analyzer
- 스타
- 88
- Tools
- 2
- 다운로드, 30일
- —
- 최신 버전
- 0.1.16
- 마지막 커밋
- 2026년 11월 15일
- 라이선스
- Apache-2.0
Trustabl MCP란?
결정론적 정적 분석을 사용하여 9가지 SDK에 걸친 AI agent 코드의 신뢰성 및 안전성 결함을 찾아내고 수정합니다. 2개 도구를 제공합니다. 예: scan, version.
프로젝트 README에서 생성된 요약
Trustabl MCP server 정보
Trustabl은 AI agent 코드의 신뢰성 및 안전성 결함을 식별하고 복구하도록 설계된 결정론적 정적 분석 스캐너를 제공합니다. 다양한 agent 프레임워크를 사용하는 개발자를 위해 구축되었으며 Claude Agent SDK, OpenAI Agents SDK, Google ADK, LangChain, Pydantic AI를 포함한 9가지 SDK에 대해 심층적인 커버리지를 제공합니다. 이 도구는 7가지 언어를 분석하여 모호한 tool 설명, 누락된 timeout, 타입이 지정되지 않은 parameter, 과도한 tool 권한 부여와 같은 문제를 찾아냅니다.
이 스캐너는 stdio MCP server 또는 CLI를 통해 로컬 머신에서 완전히 실행되므로 코드가 클라우드에 업로드되지 않으며 초기 스캔을 위해 LLM이 필요하지 않습니다. 스캔 프로세스는 오프라인으로 진행되며 API key가 필요하지 않지만, enrich command를 통해 자동 수정을 적용할 때는 기존의 Anthropic, OpenAI 또는 Google key를 사용합니다. 분석 결과는 사람이 읽을 수 있는 형식, JSON 또는 SARIF 형식으로 출력되어 GitHub Actions, GitLab 또는 Bitbucket과 같은 CI/CD 파이프라인에 통합하여 심각도 임계값에 따라 빌드를 제어하는 데 적합합니다.
활용 사례
- 1CI/CD 빌드 게이팅팀은 exit code를 사용하여 빌드 프로세스 중에 안전하지 않은 agent 코드가 프로덕션에 배포되는 것을 방지할 수 있습니다.
- 2로컬 보안 감사개발자는 코드를 업로드하지 않고도 제한 없는 shell access와 같은 보안 위험을 찾기 위해 agent 리포지토리에 대한 오프라인 스캔을 수행할 수 있습니다.
- 3표면별 준비도 점수 산정AI client는 리포지토리 내의 skills, subagents 또는 tools와 같은 특정 구성 요소의 신뢰성 점수를 평가할 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
Trustabl MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 Trustabl MCP 설치
$ claude mcp add agent-reliability-analyzer -- docker run -i --rm ghcr.io/trustabl/agent-reliability-analyzer:0.1.16 mcpCursor에 Trustabl MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"agent-reliability-analyzer": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/trustabl/agent-reliability-analyzer:0.1.16",
"mcp"
]
}
}
}VS Code에 Trustabl MCP 설치
.vscode/mcp.json
{
"servers": {
"agent-reliability-analyzer": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/trustabl/agent-reliability-analyzer:0.1.16",
"mcp"
]
}
}
}VS Code CLI에 Trustabl MCP 설치
$ code --add-mcp '{"name":"agent-reliability-analyzer","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/trustabl/agent-reliability-analyzer:0.1.16","mcp"]}'Claude Desktop에 Trustabl MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"agent-reliability-analyzer": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/trustabl/agent-reliability-analyzer:0.1.16",
"mcp"
]
}
}
}Codex에 Trustabl MCP 설치
$ codex mcp add agent-reliability-analyzer -- docker run -i --rm ghcr.io/trustabl/agent-reliability-analyzer:0.1.16 mcpCodex config.toml에 Trustabl MCP 설치
~/.codex/config.toml
[mcp_servers.agent-reliability-analyzer] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/trustabl/agent-reliability-analyzer:0.1.16", "mcp"]
Gemini CLI에 Trustabl MCP 설치
$ gemini mcp add -s user agent-reliability-analyzer docker -- run -i --rm ghcr.io/trustabl/agent-reliability-analyzer:0.1.16 mcpGemini settings.json에 Trustabl MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"agent-reliability-analyzer": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/trustabl/agent-reliability-analyzer:0.1.16",
"mcp"
]
}
}
}HostedMCP가 2026년 11월 16일에 실행 확인
ghcr.io/trustabl/agent-reliability-analyzer:0.1.16 0.1.16을(를) 네트워크와 키가 없는 격리된 컨테이너에서 이 명령으로 실행했습니다. 응답하며 도구 2개를 보여 주었습니다.
Trustabl MCP 도구 2
tools/list로 서버에서 직접 읽음scanScan a local directory or repository for AI-agent security misconfigurations with Trustabl. Returns the structured scan result (findings, scores, and discovered inventory) as JSON.
versionReport the Trustabl build version, commit, and build date.
| scan | Scan a local directory or repository for AI-agent security misconfigurations with Trustabl. Returns the structured scan result (findings, scores, and discovered inventory) as JSON. | |
| version | Report the Trustabl build version, commit, and build date. |
구성
ANTHROPIC_API_KEYCGO_ENABLEDCOSIGN_PASSWORDLANGSMITH_API_KEYOPENAI_BASE_URLTRUSTABL_LLM_MODELTRUSTABL_TELEMETRY
| 이름 | 설명 | 유형 |
|---|---|---|
| ANTHROPIC_API_KEY | — | |
| CGO_ENABLED | — | |
| COSIGN_PASSWORD | — | |
| LANGSMITH_API_KEY | — | |
| OPENAI_BASE_URL | — | |
| TRUSTABL_LLM_MODEL | — | |
| TRUSTABL_TELEMETRY | — |
자동 검사
2026년 11월 16일에 실행됨전체 보고서 →아직 인증되지 않았습니다. 서버는 80점 이상의 점수, 심각한 결함 없음, 그리고 검사에 충분한 데이터를 갖추어야 합니다. 검사 방식 · 점수를 높이기 위해 수정할 항목
- 소스 저장소 연결 및 접근 가능trustabl/agent-reliability-analyzer is public and reachablegithub.com/trustabl/agent-reliability-analyzer ↗통과
- 패키지가 이 저장소를 소스로 명시검사되지 않음
- 빌드 출처(Sigstore 증명)검사되지 않음
- 오픈 소스 라이선스 (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-15github.com/trustabl/agent-reliability-analyzer ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음검사되지 않음
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
- 모델에 대한 숨겨진 지침 없음2 tool descriptions and the README read; no override phrases, credential paths or hidden characters통과
- 파괴적인 도구에 라벨 표시됨No tool named like delete, drop or exec통과
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기Agent Reliability Analyzer — find and fix AI agent reliability gaps
Agent Reliability Analyzer is Trustabl's open-source, deterministic scanner that finds and fixes agent reliability failures in AI agent code before it reaches production. Find what will make your AI agent fail — then fix it with one command.
Deterministic static analysis for agent code, across nine SDKs and seven languages. It runs entirely on your machine: no cloud scanner, no account, no code upload, no LLM.
Agent reliability coverage as of Oct 2026: 340+ rules · 9 SDKs · 7 languages · 5 scopes
If Agent Reliability Analyzer saves you a production incident, please ⭐ the repo — it helps other teams find it.
Trustabl scans an agent repository for the gaps that break agents in production: tool descriptions too vague for a model to know when to use them, missing retry and timeout handling, untyped parameters, absent guardrails, and tool grants that exceed what the agent claims to do. Then it applies the fix directly to your source.
Every other agent scanner hands you a report. Trustabl hands you a patch.
Reliability is engineered before deployment, not observed after it.
Scanning runs entirely on your machine. No cloud scanner, no account, no code upload, no LLM — deterministic static analysis.
docker run --rm -v "$PWD:/repo" ghcr.io/trustabl/trustabl:latest scan /repo # try it, nothing installed
brew install trustabl/tap/trustabl # macOS / Linux
scoop bucket add trustabl https://github.com/trustabl/scoop-bucket # Windows
scoop install trustabl
trustabl scan . # find issues (fully local)
trustabl scan . --format json > scan.json
trustabl enrich --input scan.json --repo . --diff --apply # preview, then fix
9 SDKs · 7 languages · human, JSON, or SARIF 2.1.0 output ·
CI-friendly exit codes · also runs as a local stdio MCP server (trustabl mcp).
Deepest coverage for Claude Agent SDK, OpenAI Agents SDK, Google ADK, and MCP servers. Also scans LangChain / LangGraph, CrewAI, AutoGen / AG2, Pydantic AI, and the Vercel AI SDK — see COVERAGE.md for the full matrix.
Scanning needs no key and no network. Applying fixes uses your own Anthropic, OpenAI, or Google key.
What an agent reliability scan looks like
Real output from an agent reliability scan of a repo that ships a Claude Agent SDK client, an MCP server, a subagent, and two skills:
$ trustabl scan .
Scan summary
Languages: typescript, javascript
SDKs: claude_agent_sdk
Tool definitions: 2 (custom tools with function bodies)
Agent tool grants: 14 (tool names the agent may call)
MCP servers: 1 (createSdkMcpServer)
Subagents: 1 (inbox-searcher)
Skills: 2 (action-creator, listener-creator)
Findings: 14
Overall score: 66%
Surface readiness
skill:action-creator 45% (5 findings)
skill:listener-creator 54% (4 findings)
agent:AIClient.queryStream 64% (2 findings)
subagent:inbox-searcher 79% (1 finding)
tool:search_inbox 98% (1 finding)
tool:read_emails 100% (0 findings)
Findings
inbox-searcher
[CSDK-201] HIGH Subagent is granted Bash (agent/.claude/agents/inbox-searcher.md:1-5)
A subagent with shell access can run arbitrary commands if it is
compromised or misdirected.
fix: Remove `Bash` from the subagent's `tools:` list unless shell access
is essential. Prefer specific tools (Read, Grep, Glob) for read-only roles.
Three things worth noticing:
- It scores each surface separately. A repo-wide number hides the problem;
skill:action-creatorat 45% tells you where to look first. - Every finding carries a fix, not just a complaint — and
trustabl enrich --applywrites those fixes to source. - The exit code is the CI gate.
0when nothing reaches medium severity,1when something does, so a pipeline can stop a bad agent from shipping.
AI agents pass their demo and fail in production
Most agent reliability failures are not exotic. They are the same handful of gaps, over and over:
- An agent holding shell tools with no input guardrails
- A tool making an HTTP call with no timeout, hanging the whole run
- Untyped tool parameters, so the model guesses and guesses wrong
- No observability wired at all, so the first three have no trace to read
- A tool description so vague the model calls the wrong tool — 56% of MCP tool descriptions fail to state their purpose clearly, and 97.1% carry at least one description defect (Hasan et al., MCP Tool Descriptions Are Smelly!, arXiv 2602.14878 — 856 tools across 103 servers)
- A subagent granted
Bashdespite a read-only description - A skill that auto-approves unrestricted shell access
- No retry handling, so one transient 500 fails the task
- An agent loop with no iteration bound, burning tokens until it is killed
- A user-controlled URL flowing into a fetch — SSRF, from your agent
Every one of these is visible in the source before the agent ever runs. Trustabl finds them in seconds, offline, with no LLM — and fixes them.
The rest of this document explains what Trustabl reasons about and how the scan works, then covers building and running it. For the full implementation reference see ARCHITECTURE.md; for the at-a-glance SDK coverage matrix see COVERAGE.md.
What it analyzes — agent reliability across five scopes
Agent Reliability Analyzer does not treat a repository as one undifferentiated blob. Every agent reliability rule is classified into exactly one of five scopes, and each scope receives a different typed input:
tool— fires once per tool definition. Input: aToolDef(a@function_tool/@tool/@claude_toolfunction, a Claude TStool(name, description, schema, handler)factory call, aFunctionTool(fn)ADK wrapper, an@server.toolMCP registration, or a bare shell-invoking function) plus its parsed file. Catches a missing docstring, an HTTP call with no timeout, untyped parameters, or an unnormalized path flowing intoopen(). (Hosted tools likeWebSearchTool()are agent-scope edge data, captured asHostedToolDef, notToolDef.)agent— fires once per agent declaration. Input: anAgentDef— a PythonAgent(...)/SandboxAgent(...)/AgentDefinition(...)call, a Claude TS typed-constAgentDefinition, a Claude TS sub-agent inline inoptions.agents, or the Claude TSquery(...)main-thread agent (QueryMainAgent) — with every constructor kwarg captured and its edges to tools, handoffs, and guardrails resolved. Catches an agent with shell tools and noinput_guardrails,tool_use_behavior="stop_on_first_tool"paired with filesystem-touching tools, or a main-thread agent with unrestrictedallowedTools.subagent— fires once per Claude Code subagent markdown declaration. Discovery is hybrid: canonical.claude/agents/*.md(any path depth, monorepo-safe) PLUS a frontmatter-shape fallback over all markdown files (gated onname+tools/model) that catches flat-collection repos which ship subagents undercategories/*.md,plugins/<x>/agents/*.md, or similar layouts. Input: aSubagentDefparsed from frontmatter —name,description,tools[](verbatim) +ToolGrants[](parsed permission grammar),disallowedTools,model,permissionMode(incl.bypassPermissions),mcpServers,skills,isolation,hasHooks. Catches a subagent granted the built-inBashtool despite a read-only description (CSDK-110). Subagent presence alone contributesclaude_agent_sdktoSDKsDetected, so the Claude pack loads and CSDK-110 fires on pure-markdown subagent collections.skill— fires once per Claude Code skill (SKILL.md, any path depth). Input: aSkillDefparsed from frontmatter —name,description,allowed-tools→ToolGrants[],disable-model-invocation— plus body facts (dynamic-context exec commands, external URLs, prompt-injection markers) and a bundled-file inventory. Catches a skill that auto-approves unrestrictedBash(CSKILL-001), runs a dynamic-context command that performs network egress or reads secrets before the model sees it (CSKILL-003), or is model-invocable while granting side-effecting tools (CSKILL-050). Skills are markdown, so skill rules carry nolanguage:; theclaude_skillpack loads whenever aSKILL.mdis present.repo— fires once per scan against the whole inventory. Catches project-wide gaps such as the OpenAI Agents SDK being present with no custom trace processor configured.
The agent is the unit of analysis, not the repo
A repo can declare zero, one, or many agents, across one or more SDKs. Two agents in the same repo can be in completely different security postures — one wired with input/output guardrails, the other not. Agent-scoped findings therefore attribute to a specific agent at its constructor call site; flattening them to a single repo-level verdict would lose that attribution and be wrong. Discovery builds a small per-repo graph (tools, agents, subagents, and the edges between them) so agent-scope and subagent-scope rules can query it.
Rules are scoped to one SDK and one language
A Claude-SDK rule and an OpenAI-Agents-SDK rule that detect the same
conceptual problem (a missing timeout, say) are two separate rules with
SDK-specific explanation and fix text — there is no cross-SDK casting.
When a repo declares agents from multiple SDKs side by side, each agent is
checked only against the rules for the SDK that declared it. The same
holds across languages: a language: python rule will not fire on a
TypeScript agent.
How it reasons — the scanning pipeline
Agent Reliability Analyzer (the trustabl CLI) scans in four steps. Each step's output is the typed input to the
next, with no shared state between runs — and the inventory the early
steps build is what makes policy selection data-driven rather than
statically configured.
The binary ships with no embedded rules. Before the pipeline runs,
Trustabl resolves its detection rules from a separate git repository
(agent-reliability-rules) —
fetching the latest, caching the clone locally, and falling back to the
cache when the network is unreachable. This decouples rule updates from
binary releases: rules can be added or changed without rebuilding the
scanner. The resolved rules commit is recorded in the result and folded
into the ScanID, so a scan is honest about which rules produced it.
If no rules can be fetched and none are cached, the scan exits 2 and
tells you to run trustabl rules pull — Trustabl never runs rule-less.
flowchart LR
target[("Agent repo<br/>(local path or GitHub URL)")]
recon["Recon<br/>files · SDK deps"]
inv["Inventory<br/>Python + TS AST:<br/>tools · agents ·<br/>subagents · MCP servers"]
pol["Policy selection<br/>load rules per<br/>detected SDK ·<br/>META findings"]
ana["Analysis<br/>tool · agent · subagent ·<br/>repo detectors"]
score["Scoring<br/>per-surface score ·<br/>overall readiness"]
out[("ScanResult<br/>findings · scores<br/>(human / JSON / SARIF)")]
target --> recon --> inv --> pol --> ana --> score --> out
- Recon — walk the repo and answer "what's in here" cheaply, without
parsing any source language: languages present (by extension), SDK
dependencies declared in manifests (
pyproject.toml/requirements.txt/Pipfile/poetry.lock/package.jsonfor theclaude-agent-sdk/@anthropic-ai/claude-agent-sdk/openai-agents/@openai/agents/google-adk/@google/adkneedles), the file inventory, and discovered agent components (MCP configs, hook scripts,CLAUDE.mdandAGENTS.mdguidance docs,.claude/agents/*.mdsubagents at any depth,SKILL.mdskills, slash commands at both.claude/commands/*.mdand<plugin-root>/commands/*.md,.claude-plugin/{plugin,marketplace}.jsonmanifests, sandbox policies, and the repo-root.github/workflows/*.ymlGitHub Actions workflows). No tree-sitter parses happen here — this step decides whether the expensive AST work is even worth attempting. - Inventory — for each language Recon cleared, do the AST work and
extract a typed inventory:
ToolDefs with their config and body facts,AgentDefs with all kwargs captured,SubagentDefs /SkillDefs /SlashCommandDefs /PluginManifests parsed from markdown and JSON frontmatter,MCPServerDefs, guardrails, sessions, and the resolved edges between agents and the tools/guardrails they reference. Detectors read fields off these structs — they never re-parse raw source. - Policy selection — load only the rule packs for SDKs actually
observed in code. An SDK seen in code with no shipped pack emits a
META-001info finding ("Trustabl does not currently audit this SDK") — silence on an unknown SDK is wrong. A dep declared but never used in code emits a different info finding flagging the drift. - Analysis — run the selected scope-aware detectors against the inventory. Findings carry the scope they fired at and attribute to the right location: tool file/line, agent call site, subagent markdown file, or the manifest.
Three properties fall out of this staging, by design:
- Performance. A repo with no Python skips Python AST work; a repo with only Claude TS code skips Python AST work AND OpenAI policy loading.
- Honest coverage. An "unaudited SDK" info finding is louder than a
zero-findings clean bill of health on an SDK Trustabl doesn't know. A
META-004finding further distinguishes "audited and clean" from "could not audit — discovery extracted nothing a rule targets." - Determinism is a contract. Same inputs → same
ScanID, and the report is byte-stable across runs (findings sorted by(RuleID, FilePath, Line), inventory slices sorted deterministically). CI consumers can diff scans without spurious churn.
See ARCHITECTURE.md § 2 for the full diagram with typed inputs at each step.
What's wired today
Tool/agent AST discovery is wired for:
- Python — Claude Agent SDK (decorators), OpenAI Agents SDK, Google
ADK, LangChain / LangGraph, CrewAI, AutoGen / AG2, and Pydantic AI.
Discovery extracts tool definitions, agent constructors, hosted
tools, MCP servers, guardrails, sessions. The bare
Agent(...)constructor shared by OpenAI / ADK / CrewAI / Pydantic AI is import-gated per SDK so the classes never cross-match, and the shared@tooldecorator is routed to the owning SDK by its import binding. - TypeScript — Claude Agent SDK (the
tool()factory, thequery()main-threadQueryMainAgent, inline-in-query()sub-agents, typed-constAgentDefinitions,createSdkMcpServerand the fouroptions.mcpServersconfig literals), OpenAI Agents SDK (thetool({...})factory,new Agent({...})andAgent.create({...}), 9 hosted-tool factories, MCP server classes across 3 transports plus theMCPServerswrapper, 4defineXguardrail factories, and theMemorySession/OpenAIConversationsSession/OpenAIResponsesCompactionSessionsession classes — gated on imports from@openai/agents,@openai/agents-core, or@openai/agents-openai), and Google ADK (thenew FunctionTool({...})constructor, 5 agent constructors —new LlmAgent({...})/SequentialAgent/ParallelAgent/LoopAgent/RoutedAgent— 13 hosted-tool classes, andsubAgentsedges — gated on imports from@google/adk), LangChain / LangGraph (thetool(fn, {...})factory,DynamicStructuredTool/DynamicTool, andcreateReactAgent/createAgent/new AgentExecutor— gated on the@langchain/*/langchain/langgraphecosystem), and the Vercel AI SDK (thetool({...})/dynamicTool({...})single-object factory, the call-basedgenerateText/streamText/generateObject/streamObjectagents and the classToolLoopAgent/Experimental_Agent, withtoolswalked as an object/record, plus the<provider>.tools.*()hosted tools — gated on the bareaiimport). Handles.ts/.tsx/.mts/.ctsplus JavaScript.js/.jsx/.mjs/.cjswith thetree-sitter-typescriptandtree-sitter-tsxgrammars (JavaScript routes to the tsx grammar — a JS superset — and is audited by the samelanguage: typescriptrule packs). TypeScript rule packs ship for the Claude Agent SDK (CSDK-010/011/012/013/014/016 tool rules; CSDK-120/130/131 agent rules), OpenAI Agents SDK (OAI-016/017/019/022/024 tool rules; OAI-105/116 agent rules), Google ADK (ADK-013/015/016 tool rules; ADK-109 agent rule), MCP (MCP-011/012/013/014 tool rules), LangChain (LC-010/011/012/013/014 tool rules; LC-111 agent rule), and the Vercel AI SDK (VAI-001..008 tool/agent rules; VAI-012 repo rule). A TS repo for any of these no longer produces a blanketMETA-004; seeCOVERAGE.mdfor the full matrix.
JavaScript (.js / .jsx / .mjs / .cjs) is AST-parsed through the shared
TypeScript-family pipeline: its tools and agents are discovered, tagged
javascript, and audited by the language: typescript rule packs (both ES
import and CommonJS require() bindings are recognized). Go has
tree-sitter-go discovery for MCP tools (mark3labs/mcp-go and the official
modelcontextprotocol/go-sdk), audited by the language: go rules in the MCP
pack. C# has tree-sitter-c-sharp discovery for the official ModelContextProtocol
SDK's [McpServerTool] methods, audited by the language: csharp rules. PHP has
tree-sitter-php discovery for #[McpTool]-attributed methods (official mcp/sdk
and community php-mcp/server), audited by the language: php rules. Rust has
tree-sitter-rust discovery for the official rmcp crate's #[tool]-attributed
methods (descriptions read from the description = "..." arg or the /// doc
comment), audited by the language: rust rules; other Go, .NET, PHP, and Rust
SDKs are recognized as files by Recon but not yet AST-parsed.
The rule schema's language: field gates per-language rule sets.
Trustabl MCP 질문
Trustabl MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add agent-reliability-analyzer -- docker run -i --rm ghcr.io/trustabl/agent-reliability-analyzer:0.1.16 mcp를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
Trustabl MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
Trustabl MCP는 어떤 도구를 제공하나요?
2개 도구를 제공합니다. 예: scan, version.
스캐너를 사용하려면 인터넷 연결이나 클라우드 업로드가 필요한가요?
아니요, 스캐너는 로컬 머신에서 완전히 실행됩니다. 클라우드 스캐너, 계정, 코드 업로드가 필요하지 않으며 스캔을 위해 LLM도 필요하지 않습니다.
어떤 출력 형식을 지원하나요?
이 도구는 사람이 읽을 수 있는 형식, JSON, SARIF 2.1.0 출력 형식을 지원합니다.