ClaudeをあらゆるAPIに向けましょう。JitAPIは、どのエンドポイントをどのような順序で呼び出すべきかを自動的に判断します。
JitAPIは、ClaudeがOpenAPI仕様からあらゆるAPIと対話できるようにするMCPサーバーです。何百ものエンドポイントをコンテキストに詰め込む代わりに、JitAPIはセマンティック検索と依存関係グラフを使用して必要なものだけを抽出します。その後、Claudeが呼び出しを計画・実行します。
https://github.com/user-attachments/assets/53f72f89-a41a-4a9c-a688-ec876ea05fbd
Stripeには300以上のエンドポイントがあり、GitHubには800以上あります。仕様全体をClaudeのコンテキストに読み込むとトークンを浪費し、ハルシネーションの原因となります。使用するすべてのAPIに対してカスタムMCPサーバーを書くのはスケーラブルではありません。
JitAPIはこれを解決します： OpenAPI仕様を一度登録すれば、あとは必要なものを自然言語で尋ねるだけです。適切なエンドポイントを見つけ、それらの間の依存関係を解決し、Claudeが呼び出しを実行できるようにします。
Related MCP server: OpenAPI to MCP
pip install jitapiClaude Codeの設定（.mcp.json）に追加します：
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}以上です。APIキーは不要です。JitAPIはローカル埋め込みをすぐに使用します。
次にClaudeで：
You: Register the GitHub API from https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json
Claude: ✓ Registered GitHub v3 REST API — 1,107 endpoints indexed
You: List my repos
Claude: [searches for "list repositories for authenticated user" → finds GET /user/repos → executes]
Here are your repositories: ...キラー機能：複数のAPIを登録し、それらにまたがる質問をすることができます。JitAPIは登録されたすべてのAPIを検索し、Claudeが呼び出しをチェーンします。
You: Register the TMDB API and OpenWeatherMap API
Claude: ✓ Registered both APIs
You: Find the top popular movie on TMDB, then get the weather where it was filmed
Claude: [searches TMDB → GET /movie/popular → GET /movie/{id} for production locations
→ searches OpenWeather → GET /data/2.5/weather with the city]
The #1 popular movie is "Inception", filmed in Los Angeles.
Current weather in LA: 72°F, partly cloudy.Register API Ask a question
│ │
▼ ▼
Parse OpenAPI spec Embed query → vector search
│ │
▼ ▼
Build dependency graph Find relevant endpoints
│ │
▼ ▼
Embed all endpoints Expand with dependencies
│ │
▼ ▼
Store in vector DB Return schemas → Claude executes登録 — OpenAPI仕様を解析し、依存関係グラフ（どのエンドポイントが他のどのエンドポイントからのデータを必要とするか）を構築し、すべてのエンドポイントに対して検索可能な埋め込みを作成します
検索 — 質問すると、JitAPIはクエリを埋め込み、コサイン類似度を通じて最も関連性の高いエンドポイントを見つけます
展開 — 依存関係グラフが必要な前提条件のエンドポイントを追加します（例：「POST /orders の user_id を取得するために、まず GET /users を呼び出す必要がある」）
実行 — Claudeはエンドポイントのスキーマを取得し、ステップ間でデータを渡しながらAPI呼び出しを行います
ツール | 説明 |
| OpenAPI仕様URLからAPIを登録する |
| 登録済みのすべてのAPIとそのエンドポイント数を一覧表示する |
| 自然言語を使用してエンドポイントをセマンティック検索する |
| 依存関係解決と完全なスキーマを備えた関連エンドポイントを見つける |
| 特定のエンドポイントの完全なスキーマを取得する |
| 認証、パスパラメータ、クエリパラメータ、ボディを指定して単一のAPI呼び出しを実行する |
| 認証を設定する（APIキー、ベアラートークン、基本認証） |
| 登録済みのAPIとそのすべてのデータを削除する |
プロジェクトディレクトリに .mcp.json を作成します（グローバルアクセスの場合は ~/.claude.json）：
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}Claude Desktopの設定に追加します：
OS | 設定パス |
macOS |
|
Windows |
|
Linux |
|
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}JitAPIはローカル埋め込み（fastembed）でそのまま動作するため、APIキーは不要です。大規模なAPIで検索品質を向上させるには、クラウド埋め込みプロバイダーを追加できます：
プロバイダー | 品質 | セットアップ |
ローカル（デフォルト） | 良好 | 不要 — すぐに動作 |
Voyage AI（推奨） | 非常に高い |
|
OpenAI | 非常に高い |
|
Cohere | 高い |
|
MCP設定の env ブロックにAPIキーを設定します：
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"],
"env": {
"VOYAGE_API_KEY": "your-key-here"
}
}
}
}プロバイダーは利用可能な環境変数から自動検出されます。優先順位：Voyage AI > OpenAI > Cohere > ローカル。
登録後にAPI認証を設定します。推奨されるアプローチは環境変数を使用することです。これにより、シークレットがディスクに書き込まれることはありません：
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"],
"env": {
"GITHUB_TOKEN": "ghp_...",
"OPENWEATHER_API_KEY": "your-key-here"
}
}
}
}次に、Claudeに環境変数を使用するように伝えます：
You: Set bearer auth for GitHub using env var GITHUB_TOKEN
Claude: [calls set_api_auth with auth_type="bearer", env_var="GITHUB_TOKEN"]
✓ Auth configured for github (from env var $GITHUB_TOKEN)env_var を使用すると、JitAPIはリクエスト時に環境からシークレットを読み取ります。環境変数名のみが永続化され、認証情報自体は決して永続化されません。
認証情報を直接渡すこともできます（0600権限で ~/.jitapi/auth.json に保存されます）：
You: Set API key auth for OpenWeather with param name "appid"
Claude: [calls set_api_auth with auth_type="api_key_query", credential="...", param_name="appid"]
✓ Auth configured for openweatherサポートされている認証タイプ：bearer、api_key_header、api_key_query、basic。
セキュリティ上の注意：
env_varを使用する場合、認証情報は実行時に解決され、ファイルシステムに触れることはありません。認証情報を直接渡す場合、シークレットは~/.jitapi/auth.jsonにプレーンテキストのJSONとして保存されます（ファイル権限0600、ディレクトリ0700）。本番環境ではenv_varアプローチを推奨します。
変数 | 必須 | 説明 |
| いいえ | Voyage AI APIキー（推奨クラウドプロバイダー） |
| いいえ | OpenAI APIキー（代替クラウドプロバイダー） |
| いいえ | Cohere APIキー（代替クラウドプロバイダー） |
| いいえ | データディレクトリ（デフォルト： |
| いいえ | DEBUG, INFO, WARNING, ERROR（デフォルト：INFO） |
git clone https://github.com/nk3750/jitapi.git
cd jitapi
pip install -e ".[dev]"
pytest
ruff check src/MIT
Execute an API call. Make sure authentication is configured first.
| Name | Required | Description | Default |
|---|---|---|---|
| api_id | Yes | The API identifier | |
| endpoint_id | Yes | The endpoint to call (e.g., 'GET /users/{id}') | |
| path_params | No | Path parameter values | |
| query_params | No | Query parameter values | |
| body | No | Request body for POST/PUT/PATCH |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the auth prerequisite but fails to disclose that this tool makes external network requests, may have side effects depending on the HTTP method (POST/PUT/DELETE), or describe the response format. Significant gaps remain.
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 sentences with zero waste: first states purpose, second states prerequisite. Efficiently front-loaded and appropriately sized for the information provided.
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?
For a tool with 5 parameters, nested objects, no output schema, and zero annotations, the description is insufficient. It omits what the tool returns, error handling behavior, and whether operations are potentially destructive (mutations possible via POST/PUT in endpoint_id).
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?
Input schema has 100% description coverage (all 5 parameters documented). The description adds no parameter-specific semantics, but baseline 3 is appropriate since the schema already comprehensively documents api_id, endpoint_id, path_params, query_params, and body.
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 uses specific verb 'Execute' and resource 'API call', clearly distinguishing this runtime/execution tool from sibling management tools like register_api, delete_api, and list_apis. However, it lacks explicit scope clarification (e.g., 'HTTP request to configured endpoints') that would make it a 5.
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 one critical prerequisite ('Make sure authentication is configured first'), implying it should be used after set_api_auth. However, it lacks explicit 'when to use vs when not to use' guidance or alternatives (e.g., 'use get_endpoint_schema to inspect before calling').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete a registered API and all its data including endpoints, embeddings, dependency graph, and authentication credentials.
| Name | Required | Description | Default |
|---|---|---|---|
| api_id | Yes | The API identifier to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and successfully discloses the destructive cascade (endpoints, embeddings, credentials). However, it omits critical mutation context such as irreversibility, permission requirements, or confirmation behavior.
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 a single, front-loaded sentence with zero waste. Every clause earns its place by specifying the action and enumerating the cascading deletion scope without redundancy.
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?
For a single-parameter destructive operation with no output schema, the description adequately covers the deletion scope. It could be improved by mentioning return value indicators or confirmation requirements, but it satisfies the essential disclosure needs for this tool type.
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?
The input schema has 100% description coverage for the single 'api_id' parameter. The description does not add semantic detail beyond the schema's 'The API identifier to delete', meeting the baseline expectation when schema coverage is high.
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 provides a specific verb ('Delete') and resource ('registered API'), and explicitly distinguishes this from sibling tools by detailing the comprehensive scope of deletion ('all its data including endpoints, embeddings, dependency graph, and authentication credentials').
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 the tool is for permanent removal by enumerating what gets destroyed, but lacks explicit when-to-use guidance, prerequisites, or named alternatives (e.g., when to use this vs. simply unregistering or disabling).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the full schema for a specific endpoint. Use this to get detailed parameter and response information.
| Name | Required | Description | Default |
|---|---|---|---|
| api_id | Yes | The API identifier | |
| endpoint_id | Yes | The endpoint identifier (e.g., 'GET /users/{id}') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to indicate whether this is a safe/idempotent read operation, what format the schema is returned in, or whether there are rate limits or caching considerations. It only repeats the functional purpose.
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 consists of two efficient sentences with zero waste. It is front-loaded with the action ('Get the full schema') followed immediately by usage context, making it easy for an agent to parse quickly.
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 simplicity (2 parameters, no nested objects) and 100% schema coverage, the description is minimally adequate. However, since no output schema exists, the description could have been more specific about the return structure beyond 'detailed parameter and response information.'
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?
The input schema has 100% description coverage ('The API identifier' and 'The endpoint identifier'), establishing a baseline of 3. The description adds minimal parameter semantics beyond referencing 'a specific endpoint,' relying entirely on the schema to document the parameter purposes and format.
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 clearly states the tool retrieves 'the full schema for a specific endpoint' with specific verb (get) and resource (schema). It implies distinction from sibling 'search_endpoints' by emphasizing 'full schema' and 'detailed' information versus listing, though it doesn't explicitly name the alternative.
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 second sentence provides implied usage guidance ('Use this to get detailed parameter and response information'), suggesting when to invoke it. However, it lacks explicit 'when not to use' guidance or comparison to siblings like 'call_api' or 'search_endpoints' that might be confused for this use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get relevant endpoints with dependency resolution and full schemas for accomplishing a task. Returns search results expanded with their dependencies so you can plan and execute the right API calls in the right order. After reviewing the results, use call_api to execute each step.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What you want to accomplish (e.g., 'create a user and place an order') | |
| api_id | Yes | The API to use | |
| max_steps | No | Maximum number of endpoints to return (default: 5) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It effectively discloses key behavioral traits: returns 'search results expanded with their dependencies' and enables planning of 'API calls in the right order.' Missing minor details like rate limits or specific error conditions, but captures the essential read-only, planning-oriented nature.
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?
Three sentences with zero waste. Front-loaded with purpose ('Get relevant endpoints...'), followed by return value description, and closes with explicit workflow guidance. 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?
Despite no output schema and no annotations, the description adequately explains what the tool returns ('search results expanded with their dependencies') and the next step in the workflow. Sufficient for a discovery/planning tool, though explicit mention of output structure would improve this to a 5.
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?
Input schema has 100% description coverage with clear examples (e.g., 'create a user and place an order'). The description mentions 'accomplishing a task' which conceptually maps to the 'query' parameter, but does not add syntax details or formatting rules beyond what the schema already provides. Baseline score appropriate for high schema coverage.
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 specific action ('Get relevant endpoints') with key features ('dependency resolution and full schemas') and scope ('accomplishing a task'). Clearly distinguishes from sibling 'call_api' by emphasizing planning versus execution, and from 'search_endpoints' by highlighting dependency resolution.
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 directs the workflow: 'After reviewing the results, use call_api to execute each step.' This creates clear separation between when to use this tool (planning/discovery) versus the sibling execution tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all registered APIs with their basic information.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It confirms a read operation via 'List' but fails to specify what 'basic information' includes, whether pagination is supported, or any rate limiting concerns.
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?
Single sentence of 9 words is appropriately concise and front-loaded with the action verb. However, given the lack of annotations and output schema, the extreme brevity leaves significant gaps that additional context could have filled.
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?
While adequate for a zero-parameter tool, the description lacks sufficient detail given the absence of an output schema and annotations. It fails to clarify what constitutes 'basic information' or how this differs from the more detailed data returned by 'get_endpoint_schema'.
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?
The input schema contains 0 parameters, establishing a baseline of 4. The description does not need to compensate for missing parameter documentation, though it confirms the parameter-less nature by implying an unfiltered 'list all' operation.
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 uses a specific verb ('List') and clear resource ('registered APIs'), and specifies scope ('all' with 'basic information'). It implicitly distinguishes from 'search_endpoints' by suggesting unfiltered enumeration versus targeted search, though it doesn't explicitly clarify this distinction.
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?
No guidance provided on when to use this versus siblings like 'search_endpoints' (for filtering) or 'get_endpoint_schema' (for detailed specification). No prerequisites or conditions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Register a new API by ingesting its OpenAPI specification. This parses the spec, builds a dependency graph, and creates searchable embeddings.
| Name | Required | Description | Default |
|---|---|---|---|
| api_id | Yes | Unique identifier for this API (e.g., 'stripe', 'github') | |
| spec_url | Yes | URL to the OpenAPI specification (JSON or YAML) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and successfully discloses internal side effects: parsing the spec, building a dependency graph, and creating searchable embeddings. However, it lacks explicit safety information (idempotency, error handling on duplicate api_id, or execution time expectations).
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 efficient sentences with zero waste: the first establishes the primary action and method, while the second explains valuable internal processing mechanics. Information is front-loaded and appropriately sized.
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 no output schema and no annotations, the description adequately covers the tool's purpose and internal mechanics (parsing, embeddings). It could be improved by clarifying idempotency behavior or return value structure, but the core functionality is well-documented given the 100% schema coverage.
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 100%, establishing a baseline of 3. The description mentions 'OpenAPI specification' which maps to spec_url and implies api_id through 'new API', but does not add syntax details, format constraints, or examples beyond the schema definitions.
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 provides a specific verb ('Register') and resource ('API'), and clearly distinguishes this from sibling tools like delete_api, call_api, or list_apis by specifying this is for 'new' API ingestion via OpenAPI specification.
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 word 'new' implies this is for initial registration rather than updating existing APIs, but there is no explicit 'when to use' guidance, workflow context, or named alternatives to guide the agent in selecting this over siblings like set_api_auth.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for API endpoints using natural language. Returns semantically similar endpoints based on the query.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Natural language description of what you're looking for | |
| api_id | No | Optional: limit search to a specific API | |
| top_k | No | Number of results to return (default: 5) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. It successfully explains the matching logic (semantic similarity) but omits operational details like auth requirements, rate limits, read-only status, error behaviors, or the structure/format of returned endpoint objects.
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 sentences with zero waste. The first establishes the action and input method; the second establishes the return value. Information is front-loaded and every word 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 simple 3-parameter structure with complete schema documentation and no output schema, the description is sufficiently complete. It conceptually explains the return value (semantically similar endpoints), though it could benefit from describing the output structure or error scenarios.
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 100%, establishing a baseline of 3. The description mentions 'natural language' which maps to the query parameter, but does not augment the schema with additional guidance like example queries, format constraints, or the relationship between api_id filtering and search scope.
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 clearly states the action (search), resource (API endpoints), and method (natural language/semantic similarity). It implicitly distinguishes from list_apis via the 'natural language' and 'semantically similar' qualifiers, but does not explicitly reference sibling tools to clarify when to use each.
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 context through 'natural language' (suggesting use when exact endpoint names are unknown), but provides no explicit when-to-use guidance, exclusions, or named alternatives like list_apis. The agent must infer when semantic search is preferred over listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Configure authentication for an API. Supports API key (header or query param) and bearer token auth. Use env_var to reference a secret from an environment variable — the credential is then resolved at request time and never stored on disk.
| Name | Required | Description | Default |
|---|---|---|---|
| api_id | Yes | The API identifier | |
| auth_type | Yes | Type of authentication | |
| credential | No | The API key or bearer token. Not required when env_var is set. | |
| env_var | No | Environment variable name that holds the credential (e.g., 'GITHUB_TOKEN'). When set, the secret is read from this env var at request time and never written to disk. | |
| header_name | No | Header name for API key (default: X-API-Key) | |
| param_name | No | Query param name for API key auth |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It successfully discloses the critical security behavior that env_var credentials are 'never stored on disk' and resolved at request time. However, it omits other important behavioral traits for a configuration tool: whether this overwrites existing auth, validation behavior, and idempotency semantics.
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 consists of three tightly constructed sentences with zero waste: sentence 1 establishes purpose, sentence 2 enumerates capabilities, and sentence 3 provides critical security guidance. Information is front-loaded and every clause 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 100% schema coverage and lack of output schema, the description adequately covers the primary function. However, for a configuration/mutation tool with zero annotations indicating side effects or safety, the description should disclose overwrite behavior and validation semantics to be considered complete. As is, it leaves operational questions unanswered.
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?
While the schema has 100% coverage (baseline 3), the description adds meaningful semantic context beyond the schema. Specifically, it clarifies the security implication of the env_var parameter ('never stored on disk'), which is not explicitly stated in the schema's technical description of the parameter, and maps the auth types to their transport mechanisms (header vs query param).
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 clearly states the specific action ('Configure authentication') and resource ('for an API'), and enumerates supported auth types (API key header/query, bearer). It implicitly distinguishes from siblings like call_api or register_api by focusing specifically on auth configuration, though it could explicitly clarify this is a prerequisite for call_api.
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 internal guidance on parameter selection ('Use env_var to reference a secret'), helping users choose between credential and env_var parameters. However, it lacks explicit workflow guidance regarding when to use this tool versus siblings (e.g., 'use this before call_api') or prerequisites for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0call_apidelete_apiget_endpoint_schemaget_workflowlist_apisregister_apisearch_endpointsset_api_authScored across 8 tools
Each tool has a clearly distinct purpose: register/delete/list for API lifecycle management, search_endpoints for discovery, get_endpoint_schema for detailed inspection, get_workflow for task planning with dependencies, set_api_auth for configuration, and call_api for execution. No overlapping functionality.
Consistent snake_case throughout with verb_noun pattern (call_api, delete_api, list_apis, register_api, search_endpoints, get_workflow, get_endpoint_schema, set_api_auth). All use standard CRUD-style verbs (get, list, search, call, set, register, delete).
8 tools is well-scoped for an API management server covering the full lifecycle: registration, listing, deletion, authentication, discovery (search), inspection (schema), planning (workflow), and execution. Each tool earns its place without redundancy.
Covers the core API lifecycle well (register, list, delete, auth, search, call) with helpful additions like workflow planning. Minor gaps: no get_api for specific API details (only list_apis), no update_api for refreshing specs without full deletion, and no way to remove auth without deleting the entire API.
Turn any task into the right API calls: discover, evaluate, and integrate public APIs.
One MCP endpoint for Claude, GPT & Gemini: 100+ tools + no-code connectors + agent workers.
Your AI Agent's Infrastructure Layer. Connect Claude, Copilot, Codex, or ChatGPT to 200+ managed open source services. Start databases, pipelines, and applications through natural language.
Discover, compare, and monitor 1,400+ APIs directly from your AI coding agent.
