런타임 제어 또는 정적 시작 방식을 통해 필요한 도구만 온디맨드로 활성화함으로써 LLM의 과부하를 방지하고 동적 MCP toolset을 관리합니다.
다른 이름 code-rabi/toolception
- 스타
- 6
- Tools
- 5
- 다운로드, 30일
- —
- 최신 버전
- —
- 마지막 커밋
- 2026년 11월 5일
- 라이선스
- Apache-2.0
Toolception MCP란?
Toolception은(는) MCP server입니다. 런타임 제어 또는 정적 시작 방식을 통해 필요한 도구만 온디맨드로 활성화함으로써 LLM의 과부하를 방지하고 동적 MCP toolset을 관리합니다. 5개 도구를 제공합니다. 예: enable_toolset, disable_toolset, list_toolsets.
프로젝트 README에서 생성된 요약
Toolception MCP server 정보
Toolception은 함수를 관리 가능한 toolset으로 그룹화하여 AI 에이전트를 위한 대규모 도구 모음을 관리할 수 있게 합니다. 수십 또는 수백 개의 도구를 가진 복잡한 MCP server를 구축하는 개발자는 이 라이브러리를 사용하여 LLM의 혼란, 토큰 낭비 및 이름 충돌을 방지할 수 있습니다. 이를 통해 도구를 선택적으로 노출하여 에이전트가 현재 작업과 관련된 특정 기능만 볼 수 있도록 보장합니다.
사용자는 런타임 제어를 위한 DYNAMIC 모드와 예측 가능한 시작을 위한 STATIC 모드 중 하나를 선택할 수 있습니다. dynamic 모드에서 클라이언트는 enable_toolset 및 disable_toolset과 같은 메타 도구를 사용하여 필요할 때 도구를 로드하며, 이는 지연 로딩을 지원하고 프롬프트 지연 시간을 줄여줍니다. static 모드는 부트스트랩 시 특정 toolset 또는 사용 가능한 모든 세트를 미리 로드합니다. 또한 이 라이브러리는 HTTP 헤더 또는 서버 측 구성 맵을 통한 권한 기반 액세스 제어를 지원하므로, 서로 다른 클라이언트가 격리된 도구 접근을 필요로 하는 멀티 테넌트 환경에 적합합니다. Node.js 25.3.0 이상이 필요하며, 스키마 유효성 검사를 위해 MCP TypeScript SDK 및 Zod 4와 통합됩니다.
활용 사례
- 1LLM 도구 혼란 감소에이전트가 방대한 카탈로그로 인해 과부하되는 것을 방지하기 위해 작업에 필요한 특정 toolset만 활성화할 수 있습니다.
- 2멀티 테넌트 보안 구현도구 접근을 제한하여 서로 다른 사용자 또는 클라이언트가 권한이 있는 특정 toolset만 볼 수 있도록 합니다.
- 3프롬프트 토큰 사용 최적화전체 라이브러리를 로드하는 대신 관련 도구만 로드하여 지연 시간과 토큰 소비를 최소화합니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
Toolception MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 Toolception MCP 설치
$ claude mcp add toolception -- npx -y toolceptionCursor에 Toolception MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"toolception": {
"command": "npx",
"args": [
"-y",
"toolception"
]
}
}
}VS Code에 Toolception MCP 설치
.vscode/mcp.json
{
"servers": {
"toolception": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"toolception"
]
}
}
}VS Code CLI에 Toolception MCP 설치
$ code --add-mcp '{"name":"toolception","type":"stdio","command":"npx","args":["-y","toolception"]}'Claude Desktop에 Toolception MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"toolception": {
"command": "npx",
"args": [
"-y",
"toolception"
]
}
}
}Codex에 Toolception MCP 설치
$ codex mcp add toolception -- npx -y toolceptionCodex config.toml에 Toolception MCP 설치
~/.codex/config.toml
[mcp_servers.toolception] command = "npx" args = ["-y", "toolception"]
Gemini CLI에 Toolception MCP 설치
$ gemini mcp add -s user toolception npx -- -y toolceptionGemini settings.json에 Toolception MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"toolception": {
"command": "npx",
"args": [
"-y",
"toolception"
]
}
}
}Toolception MCP 도구 5
README에서 감지됨enable_toolsetdisable_toolsetlist_toolsetsdescribe_toolsetlist_tools
| enable_toolset | — | |
| disable_toolset | — | |
| list_toolsets | — | |
| describe_toolset | — | |
| list_tools | — |
구성
API_TOKENUSER_ID
| 이름 | 설명 | 유형 |
|---|---|---|
| API_TOKEN | — | |
| USER_ID | — |
자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용검사되지 않음
- 파괴적인 도구에 라벨 표시됨통과
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음검사되지 않음
README
GitHub에서 보기Toolception – Dynamic MCP Tooling Library
Table of Contents
- When and why to use Toolception
- Starter guide
- Static startup
- Permission-based starter guide
- Permission configuration approaches
- Custom HTTP endpoints
- Per-session context
- API
- Permission-based client integration
- Permission-based security best practices
- Permission-based common patterns
- Client ID lifecycle
- Session ID lifecycle
- Tool types
- Startup modes
- License
When and why to use Toolception
Building MCP servers with dozens or hundreds of tools often harms LLM performance and developer experience:
- Too many tools overwhelm selection: Larger tool lists increase confusion and mis-selection rates.
- Token and schema bloat: Long tool catalogs inflate prompts and latency.
- Name collisions and ambiguity: Similar tool names across domains cause failures and fragile integrations.
- Operational overhead: Loading every tool up-front wastes resources; many tools are task-specific.
Toolception addresses this by grouping tools into toolsets and letting you expose only what’s needed, when it’s needed.
When to use Toolception
- Large or multi-domain catalogs: You have >20–50 tools or multiple domains (e.g., search, data, billing) and don’t want to expose them all at once.
- Task-specific workflows: You want the client/agent to enable only the tools relevant to the current task.
- Multi-tenant or policy needs: Different users/tenants require different tool access or limits.
- Per-session context: You need different context values (API tokens, user IDs) for each client session passed to module loaders.
- Permission-based access control: You need to enforce client-specific toolset permissions for security, compliance, or multi-tenant isolation. Each client should only see and access the toolsets they're authorized to use, with server-side or header-based permission enforcement.
- Collision-safe naming: You need predictable, namespaced tool names to avoid conflicts.
- Lazy loading: Some tools are heavy and should be loaded on demand.
Why Toolception helps
- Toolsets: Group related tools and expose minimal, coherent subsets per task.
- Dynamic mode (runtime control):
- Enable toolsets on demand via meta-tools (
enable_toolset,disable_toolset,list_toolsets,describe_toolset,list_tools). - Reduce prompt/tool surface area → better tool selection and lower latency.
- Lazy-load module-produced tools only when needed; pass shared
contextsafely to loaders. - Supports
tools.listChangednotifications so clients can react to updated tool lists.
- Enable toolsets on demand via meta-tools (
- Static mode (predictable startup):
- Preload known toolsets (or ALL) at startup for fixed pipelines and simpler environments.
- Keep only the required sets for your deployment footprint.
- Exposure policy:
- maxActiveToolsets: Cap concurrently active sets to prevent bloat.
- allowlist/denylist: Enforce which toolsets can be enabled.
- namespaceToolsWithSetKey: Default on; registers tools as
set.toolto avoid collisions and clarify intent.
- Operational safety:
- Central
ToolRegistryvalidates names and prevents collisions. ModuleLoadersare deterministic/idempotent for repeatable runs and caching.
- Central
Choosing a mode
- Prefer DYNAMIC when tool needs vary by task, you want tighter prompts, or you need runtime gating and lazy loading.
- Choose STATIC when your tool needs are stable and small, or when your client cannot (or should not) perform runtime enable/disable operations.
Typical flows
- Discovery-first (dynamic): Client calls
list_toolsets→ enables a set → calls namespaced tools (e.g.,core.ping). - Fixed pipeline (static): Server preloads named toolsets (or ALL) at startup; clients call
list_toolsand invoke as usual.
Starter guide
Step 1: Install
npm i toolception @modelcontextprotocol/server zod
Toolception 0.9 is built on MCP TypeScript SDK v2 (@modelcontextprotocol/server) and needs Zod 4 (zod ^4.6.7); Zod 3 schemas are rejected. Install the same versions toolception depends on, so your app and toolception share one copy of each. Toolception needs Node.js 25.3.0 or later.
Step 2: Import Toolception
import { createMcpServer } from "toolception";
Step 3: Define a toolset catalog
const catalog = {
quotes: { name: "Quotes", description: "Market quotes", modules: ["quotes"] },
};
Step 4: Define a tool
inputSchema should be a Zod 4 raw shape (or a Zod 4 object schema); toolception wraps a raw shape with z.object() before it calls McpServer.registerTool. A Zod 3 schema fails to enable its toolset with an E_VALIDATION error. A plain JSON Schema object (type: "object") also works: toolception registers it with the SDK's fromJsonSchema(), so clients see its properties and arguments are validated against it before your handler runs. A JSON Schema that does not compile (unknown type name, unresolved $ref, unsupported $schema dialect) fails the toolset's enable with an E_VALIDATION error that names the tool.
import { z } from "zod";
const quoteTool = {
name: "price",
description: "Return a fake price",
inputSchema: {
symbol: z.string(),
},
handler: async ({ symbol }: { symbol: string }) => ({
content: [{ type: "text", text: `${symbol}: 123.45` }],
}),
} as const;
Step 5: Provide module loaders
const moduleLoaders = {
quotes: async () => [quoteTool],
};
Step 6: (Optional) Configuration schema
const configSchema = {
$schema: "https://json-schema.org/draft/2020-12/schema",
type: "object",
properties: {
REQUIRED_PARAM: { type: "string", title: "Required Param" },
OPTIONAL_PARAM: { type: "string", title: "Optional Param" },
},
required: ["REQUIRED_PARAM"],
} as const;
Step 7: Create the MCP SDK server and start Toolception
import { McpServer } from "@modelcontextprotocol/server";
// You own the SDK server; pass a factory into Toolception (required in DYNAMIC mode)
const createServer = () =>
new McpServer({
name: "my-mcp-server",
version: "0.0.0",
}, { capabilities: { tools: { listChanged: true } } });
const { start, close } = await createMcpServer({
catalog,
moduleLoaders,
startup: { mode: "DYNAMIC" },
http: { port: 3000 },
createServer,
// configSchema, // uncomment to expose at /.well-known/mcp-config
});
await start();
Step 8: Graceful shutdown
process.on("SIGINT", async () => {
await close();
process.exit(0);
});
process.on("SIGTERM", async () => {
await close();
process.exit(0);
});
Static startup
Enable some or ALL toolsets at bootstrap. In STATIC mode every client gets its own server from createServer, with the startup toolsets already loaded:
import { McpServer } from "@modelcontextprotocol/server";
const staticCatalog = {
search: { name: "Search", description: "Search tools", modules: ["search"] },
quotes: { name: "Quotes", description: "Market quotes", modules: ["quotes"] },
};
// Load specific toolsets
createMcpServer({
catalog: staticCatalog,
startup: { mode: "STATIC", toolsets: ["search", "quotes"] },
http: { port: 3001 },
createServer: () =>
new McpServer({
name: "static-1",
version: "0.0.0",
}, { capabilities: { tools: { listChanged: false } } }),
});
// Load ALL toolsets
createMcpServer({
catalog: staticCatalog,
startup: { mode: "STATIC", toolsets: "ALL" },
http: { port: 3002 },
createServer: () =>
new McpServer({
name: "static-2",
version: "0.0.0",
}, { capabilities: { tools: { listChanged: false } } }),
});
Permission-based starter guide
Use createPermissionBasedMcpServer when you need to enforce client-specific toolset permissions. This is ideal for multi-tenant applications, security-sensitive environments, or when different clients should have different levels of access.
Step 1: Install
npm i toolception @modelcontextprotocol/server zod
Toolception 0.9 is built on MCP TypeScript SDK v2 (@modelcontextprotocol/server) and needs Zod 4 (zod ^4.6.7); Zod 3 schemas are rejected. Install the same versions toolception depends on, so your app and toolception share one copy of each.
Step 2: Import Toolception
import { createPermissionBasedMcpServer } from "toolception";
import { McpServer } from "@modelcontextprotocol/server";
Step 3: Define a toolset catalog
const catalog = {
admin: {
name: "Admin Tools",
description: "Administrative operations",
modules: ["admin"],
},
user: {
name: "User Tools",
description: "Standard user operations",
modules: ["user"],
},
};
Step 4: Define tools
const adminTool = {
name: "delete_user",
description: "Delete a user account",
inputSchema: {
userId: z.string().describe("User ID to delete"),
},
handler: async ({ userId }: { userId: string }) => ({
content: [{ type: "text", text: `User ${userId} deleted` }],
}),
} as const;
const userTool = {
name: "get_profile",
description: "Get user profile information",
inputSchema: {
userId: z.string().describe("User ID"),
},
handler: async ({ userId }: { userId: string }) => ({
content: [{ type: "text", text: `Profile for ${userId}: {...}` }],
}),
} as const;
Step 5: Provide module loaders
const moduleLoaders = {
admin: async () => [adminTool],
user: async () => [userTool],
};
Step 6: Choose permission approach
You have two options for managing permissions:
Header-Based Permissions:
- Use when you have an authentication gateway/proxy
- Permissions passed via HTTP headers
- Good for dynamic, frequently-changing permissions
- Requires external validation of headers
Config-Based Permissions:
- Use when you want server-side control
- Permissions defined in server configuration
- Better security (no client-provided permission data)
- Good for stable permission structures
Step 7: Create the permission-based MCP server
Option A: Header-Based Permissions
const createServer = () =>
new McpServer({
name: "permission-header-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog,
moduleLoaders,
permissions: {
source: "headers",
headerName: "mcp-toolset-permissions", // optional, this is default
},
http: { port: 3000 },
createServer,
});
await start();
Option B: Config-Based Permissions (Static Map)
const createServer = () =>
new McpServer({
name: "permission-config-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog,
moduleLoaders,
permissions: {
source: "config",
staticMap: {
"admin-client-id": ["admin", "user"],
"user-client-id": ["user"],
},
defaultPermissions: [], // unknown clients get no toolsets
},
http: { port: 3000 },
createServer,
});
await start();
Option C: Config-Based Permissions (Resolver Function)
const createServer = () =>
new McpServer({
name: "permission-resolver-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog,
moduleLoaders,
permissions: {
source: "config",
resolver: (clientId: string) => {
// Your custom permission logic
if (clientId.startsWith("admin-")) {
return ["admin", "user"];
}
if (clientId.startsWith("user-")) {
return ["user"];
}
return [];
},
defaultPermissions: [],
},
http: { port: 3000 },
createServer,
});
await start();
Step 8: Graceful shutdown
process.on("SIGINT", async () => {
await close();
process.exit(0);
});
process.on("SIGTERM", async () => {
await close();
process.exit(0);
});
Permission configuration approaches
Header-Based Permissions Setup
Use header-based permissions when you have an authentication gateway or proxy that validates and sets permission headers. This approach is flexible for dynamic permissions but requires external header validation.
import { createPermissionBasedMcpServer } from "toolception";
import { McpServer } from "@modelcontextprotocol/server";
const createServer = () =>
new McpServer({
name: "permission-header-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog: {
admin: {
name: "Admin",
description: "Admin tools",
modules: ["admin"],
},
user: {
name: "User",
description: "User tools",
modules: ["user"],
},
},
moduleLoaders: {
admin: async () => [
/* admin tools */
],
user: async () => [
/* user tools */
],
},
permissions: {
source: "headers",
headerName: "mcp-toolset-permissions", // optional, this is default
},
http: { port: 3000 },
createServer,
});
await start();
When to use:
- You have an authentication gateway/proxy that validates requests
- Permissions change frequently or are computed per-request
- You can ensure headers are cryptographically signed or validated
- Your auth system is external to the MCP server
Config-Based Permissions Setup (Static Map)
Use a static map when you have a fixed set of clients with known permissions. This provides server-side control and better security.
import { createPermissionBasedMcpServer } from "toolception";
import { McpServer } from "@modelcontextprotocol/server";
const createServer = () =>
new McpServer({
name: "permission-config-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog: {
admin: {
name: "Admin",
description: "Admin tools",
modules: ["admin"],
},
user: {
name: "User",
description: "User tools",
modules: ["user"],
},
},
moduleLoaders: {
admin: async () => [
/* admin tools */
],
user: async () => [
/* user tools */
],
},
permissions: {
source: "config",
staticMap: {
"admin-client-id": ["admin", "user"],
"user-client-id": ["user"],
},
defaultPermissions: [], // clients not in map get no toolsets
},
http: { port: 3000 },
createServer,
});
await start();
When to use:
- You have a fixed set of known clients
- Permissions are relatively stable
- You want the highest security level
- You want to avoid trusting client-provided data
Config-Based Permissions Setup (Resolver Function)
Use a resolver function when you need custom logic to determine permissions, such as looking up from a database or applying complex rules.
import { createPermissionBasedMcpServer } from "toolception";
import { McpServer } from "@modelcontextprotocol/server";
const createServer = () =>
new McpServer({
name: "permission-resolver-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: false } } });
const { start, close } = await createPermissionBasedMcpServer({
catalog: {
admin: {
name: "Admin",
description: "Admin tools",
modules: ["admin"],
},
user: {
name: "User",
description: "User tools",
modules: ["user"],
},
},
moduleLoaders: {
admin: async () => [
/* admin tools */
],
user: async () => [
/* user tools */
],
},
permissions: {
source: "config",
resolver: (clientId: string) => {
// Custom logic - could check database, config file, etc.
if (clientId.startsWith("admin-")) {
return ["admin", "user"];
}
if (clientId.startsWith("user-")) {
return ["user"];
}
return [];
},
staticMap: {
// optional fallback
"special-client": ["admin"],
},
defaultPermissions: [],
},
http: { port: 3000 },
createServer,
});
await start();
When to use:
- You need custom permission logic
- Permissions are computed based on client ID patterns or attributes
- You want to integrate with existing permission systems
- You need fallback behavior with staticMap
Note: Resolver functions must be synchronous. If you need to fetch permissions from external sources, do so before server creation and cache the results.
Custom HTTP endpoints
Toolception supports custom HTTP endpoints alongside MCP protocol endpoints, enabling REST-like APIs with Zod validation and type inference.
Basic usage
import { createMcpServer, defineEndpoint } from "toolception";
import { z } from "zod";
const { start } = await createMcpServer({
// ... standard options
http: {
port: 3000,
customEndpoints: [
defineEndpoint({
method: "GET",
path: "/api/users",
querySchema: z.object({
limit: z.coerce.number().int().positive().default(10),
role: z.enum(["admin", "user"]).optional(),
}),
responseSchema: z.object({
users: z.array(z.object({ id: z.string(), name: z.string() })),
}),
handler: async (req) => {
// req.query is typed: { limit: number, role?: "admin" | "user" }
// req.clientId is available from mcp-client-id header
return { users: [{ id: "1", name: "Alice" }] };
},
}),
],
},
});
Validation schemas
- querySchema: Validates URL query parameters (use
z.coercefor type conversion) - bodySchema: Validates request body (POST/PUT/PATCH)
- paramsSchema: Validates path parameters (e.g.,
/users/:userId) - responseSchema: Validates handler response (prevents invalid data leakage)
Request context
Handlers receive a typed request object:
{
body: TBody, // Validated from bodySchema
query: TQuery, // Validated from querySchema
params: TParams, // Validated from paramsSchema
headers: Record<string, string | string[] | undefined>,
clientId: string, // From mcp-client-id header or auto-generated
}
Permission-aware endpoints
Use definePermissionAwareEndpoint in permission-based servers to access client permissions:
import { createPermissionBasedMcpServer, definePermissionAwareEndpoint } from "toolception";
const { start } = await createPermissionBasedMcpServer({
// ... permission config
http: {
customEndpoints: [
definePermissionAwareEndpoint({
method: "GET",
path: "/api/me",
responseSchema: z.object({
clientId: z.string(),
allowedToolsets: z.array(z.string()),
isAdmin: z.boolean(),
}),
handler: async (req) => {
// req.allowedToolsets and req.failedToolsets are available
return {
clientId: req.clientId,
allowedToolsets: req.allowedToolsets,
isAdmin: req.allowedToolsets.includes("admin-tools"),
};
},
}),
],
},
});
Error handling
Validation failures return standardized error responses:
- 400 VALIDATION_ERROR: Request validation failed (body, query, or params)
- 500 INTERNAL_ERROR: Handler threw an exception
- 500 RESPONSE_VALIDATION_ERROR: Response validation failed
Example error response:
{
"error": {
"code": "VALIDATION_ERROR",
"message": "Validation failed for query",
"details": [
{
"code": "invalid_type",
"path": ["limit"],
"message": "Expected number, received string"
}
]
}
}
Reserved paths
Custom endpoints cannot override built-in MCP paths:
/mcp- MCP JSON-RPC endpoint/healthz- Health check/tools- Tool listing/.well-known/mcp-config- Configuration schema
Complete example
See examples/custom-endpoints-demo.ts for a full working example with GET, POST, PUT, DELETE endpoints, pagination, and permission-aware handlers.
Per-session context
Use the sessionContext option to enable per-client context values extracted from query parameters. This is useful for multi-tenant scenarios where each client needs different configuration (API tokens, user IDs, etc.) passed to module loaders.
Basic usage
import { createMcpServer } from "toolception";
import { McpServer } from "@modelcontextprotocol/server";
const { start } = await createMcpServer({
catalog: { /* ... */ },
moduleLoaders: { /* ... */ },
context: { baseValue: 'shared' }, // Base context for all sessions
sessionContext: {
enabled: true,
queryParam: {
name: 'config',
encoding: 'base64',
allowedKeys: ['API_TOKEN', 'USER_ID'], // Security: always specify
},
merge: 'shallow',
},
createServer: () => new McpServer({
name: "my-server",
version: "1.0.0",
}, { capabilities: { tools: { listChanged: true } } }),
http: { port: 3000 },
});
await start();
Client connection
# Encode session config as base64
CONFIG=$(echo -n '{"API_TOKEN":"user-secret-token","USER_ID":"123"}' | base64)
# Connect with session config
curl -X POST "http://localhost:3000/mcp?config=$CONFIG" \
-H "mcp-client-id: my-client" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"initialize",...}'
Module loader receives merged context
const moduleLoaders = {
tenant: async (ctx: any) => {
// ctx = { baseValue: 'shared', API_TOKEN: 'user-secret-token', USER_ID: '123' }
return [/* tools using ctx.API_TOKEN */];
},
};
Custom context resolver
For advanced use cases, provide a custom resolver function:
sessionContext: {
enabled: true,
queryParam: { allowedKeys: ['tenant_id'] },
contextResolver: (request, baseContext, parsedConfig) => ({
...baseContext,
...parsedConfig,
clientId: request.clientId,
timestamp: Date.now(),
}),
}
Security considerations
- Always specify
allowedKeys: Without a whitelist, any key in the query config is accepted - Fail-secure: Invalid encoding silently falls back to base context
- No logging of values: Session config values are never logged
- Filtered silently: Disallowed keys are filtered without error messages
API
Toolception MCP 질문
Toolception MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add toolception -- npx -y toolception를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
Toolception MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
Toolception MCP는 어떤 도구를 제공하나요?
5개 도구를 제공합니다. 예: enable_toolset, disable_toolset, list_toolsets, describe_toolset, list_tools.
DYNAMIC 모드와 STATIC 모드의 차이점은 무엇인가요?
DYNAMIC 모드는 메타 도구를 통해 온디emand로 toolset을 활성화하여 프롬프트 효율성을 높일 수 있으며, STATIC 모드는 안정적인 환경을 위해 시작 시 특정 또는 모든 toolset을 미리 로드합니다.
사용자별로 도구 접근을 제한할 수 있나요?
네, 권한 기반 액세스 제어를 사용하여 HTTP 헤더나 서버 측 구성 맵을 통해 클라이언트별 toolset 권한을 강제할 수 있습니다.
Zod의 어떤 버전이 필요한가요?
Toolception은 Zod 4(^4.6.7)가 필요합니다. Zod 3 스키마는 지원되지 않으며 유효성 검사 오류가 발생합니다.