Jentic
OfficialJentic MCPプラグイン
Jentic MCP を使用する理由
Jentic MCPは、開発者がAPI固有のコードを記述・保守することなく、外部APIやワークフローを迅速に発見・統合することを可能にします。MCPプロトコルとJenticのエージェントランタイムを活用することで、開発者は以下のことが可能になります。
ベンダーや実装ではなく、機能別に API とワークフローを検索します。
特定の API の詳細に依存しない統合コード サンプルを即座に生成します。
標準化された宣言型の統合を利用することで、定型句を回避し、メンテナンスを軽減します。
Jentic MCP が API 相互作用の複雑さを処理するので、機能の構築に集中できます。
Related MCP server: agent-zone-mcp
APIツール
Jentic MCP プラグインは次のツールを提供します。
search_apis: 特定の機能ニーズに一致する Jentic ディレクトリ内の API を検索しますload_execution_info: JenticディレクトリからAPIと操作の詳細な仕様を取得します。これには、mcpServers.jentic.env設定で指定する必要がある可能性のある認証情報が含まれます。execute: 特定の API またはワークフロー操作を実行します。
はじめる
推奨される方法は、 uvxを使用して GitHub リポジトリから直接サーバーを実行することです。まず、以下のコマンドでuvをインストールする必要があります。
brew install uvまたはpip install uv
Jentic UUIDを取得する
Jentic SDKを使用するには、まずJentic UUIDを取得する必要があります。最も簡単な方法はJentic CLIを使用することです。オプションでメールアドレスを入力すると、レート制限の引き上げや新機能への早期アクセスが可能になります。
pip install jentic
jentic register --email '<your_email>'これにより、UUID とそれを環境に設定するためのエクスポート コマンドが出力されます。
export JENTIC_UUID=<your-jentic-uuid>以下に示すように、MCP クライアント構成で Jentic UUID を設定します。
設定ファイルの場所は、使用しているクライアントとOSによって異なります。一般的な例を以下に示します。
ウィンドサーフィン:
~/.codeium/windsurf/mcp_config.jsonClaude デスクトップ:
~/Library/Application Support/Claude/claude_desktop_config.jsonクロードコード:
~/.claude.jsonカーソル:
~/cursor/.mcp.json
その他のクライアントの場合、MCP サーバーを追加する方法については、クライアントのドキュメントを確認してください。
{
"mcpServers": {
"jentic": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp",
"mcp"
],
"env": {
"JENTIC_UUID": "<your-jentic-uuid>"
}
}
}
}**注意:**構成ファイルを保存した後、変更を有効にするにはクライアント アプリケーション (Windsurf、Claude Desktop) を再起動する必要がある場合があります。
MCPツールの使用
MCP サーバーが実行される場合は、LLM エージェントの MCP ツールを使用して、API とワークフローを簡単に検出して実行できます。
search_apis: 特定の機能ニーズに一致する Jentic ディレクトリ内の API を検索しますload_execution_info: JenticディレクトリからAPIと操作の詳細な仕様を取得します。これには、mcpServers.jentic.env設定で指定する必要がある可能性のある認証情報が含まれます。execute: 特定の API またはワークフロー操作を実行します。
環境変数
認証が必要なAPIを使用する場合、 load_execution_infoツールは必要な環境変数を表示します。Windsurfではコマンドラインから環境変数を設定できますが、Claude Desktopなどの一部のクライアントでは、MCP設定に追加する必要があります。
{
"mcpServers": {
"jentic": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp",
"mcp"
],
"env": {
"DISCORD_BOTTOKEN=": "YOUR BOT TOKEN"
}
}
}
}代替案(開発にローカルパスを使用する):
MCPプラグインをローカルで開発している場合は、こちらを使用してください。/path/to/your/project/mcp /path/to/your/project/mcpプロジェクトディレクトリへの絶対パスに置き換えてください。
{
"mcpServers": {
"jentic": {
"command": "uvx",
"args": [
"--from",
"/path/to/your/project/mcp",
"mcp"
]
}
}
}*オプション:*特定の Jentic API を指すように、 JENTIC_API_URL環境変数をmcp_config.jsonファイルに追加します (両方の方法で機能します)。
{
"mcpServers": {
"jentic": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp",
"mcp"
],
"env": {
"JENTIC_API_URL": "https://your-jentic-api.url/"
}
}
}
}設定が完了したら、Windsurf を再起動すると、Jentic MCP ツールが使用できるようになります。
次のコマンドを実行すると、ローカルで実行されている MCP サーバーによって生成されたログを tail できます。
tail /path/to/mcp/jentic_ark2_mcp.logインストール
Smithery経由でインストール
Smithery経由で Claude Desktop 用の Jentic プラグインを自動的にインストールするには:
npx -y @smithery/cli install @jentic/jentic-tools --client claude手動インストール
pdmがインストールされていることを確認してください ( pipx install pdm )。
開発用にパッケージとその依存関係をインストールするには:
# From the project root directory (e.g., /Users/kc/c/sdk/mcp)
pdm install -G devMCPサーバーの実行
Jentic MCP プラグインは、環境のセットアップと実行を処理するuvxを使用して実行されるように設計されています。
デフォルトモード(Stdio)
--fromとmcpスクリプトを使用してプロジェクト ディレクトリをソースとして指定し、 uvxを使用して MCP プラグインを直接実行します。
ローカルパス(開発)から:
# Use --from with the project directory and specify the 'mcp' script
uvx --from /path/to/your/project/mcp mcp
# Or, if running from within the project directory:
uvx --from . mcpリモート リポジトリから (一般的な使用に推奨):
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp \
mcpこれにより、 mcpスクリプトのコールバックで定義されているデフォルトのserve --transport stdioコマンドが自動的に使用されます。
HTTPモード
サーバーを HTTP モードで実行するには (例: claude-cliでテストする場合):
ローカルパス(開発)から:
# Default HTTP (port 8010)
uvx --from /path/to/your/project/mcp mcp serve --transport http
# With custom port
uvx --from /path/to/your/project/mcp mcp serve --transport http --port 8080
# With custom host
uvx --from /path/to/your/project/mcp mcp serve --transport http --host 0.0.0.0 --port 8080リモートリポジトリから(推奨):
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp \
mcp serve --transport http --port 8080リモート Git リポジトリから実行
uvx --fromを使用して、ローカルにクローンせずに Git リポジトリ URL から MCP サーバーを直接実行することもできます。
# Example from a specific branch and subdirectory
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp
# Explanation:
# - git+https://... .git : The repository URL
# - @main : The branch, tag, or commit hash
# - #subdirectory=mcp : The folder within the repo containing the pyproject.tomlこのコマンドは、指定されたバージョンを取得し、その依存関係を一時環境にインストールし、デフォルトのコマンド ( serve --transport stdio ) を実行します。
URL フラグメントの後に--log-level DEBUGや--mockなどの他の引数を追加することもできます。
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp \
--log-level DEBUG --mockリモート ソースから HTTP モードで実行するには:
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp \
serve --transport http --port 8080その他のオプション
ログ記録
# Set logging level (applies to default stdio or explicit serve)
uvx --from /path/to/your/project/mcp mcp --log-level DEBUG
uvx --from /path/to/your/project/mcp mcp serve --transport http --log-level DEBUG
# Log to file (applies to default stdio or explicit serve)
uvx --from /path/to/your/project/mcp mcp --log-file jentic_mcp.log
uvx --from /path/to/your/project/mcp mcp serve --transport http --log-file jentic_mcp.logモックモード
実際の Jentic API Knowledge Hub に接続せずに開発用のモック モードを有効にします。
# Mock mode with default stdio
uvx --from /path/to/your/project/mcp mcp --mock
# Mock mode with explicit HTTP
uvx --from /path/to/your/project/mcp mcp serve --transport http --mock環境変数
.envファイルを使用して環境変数を提供します。
# Env file with default stdio
uvx --from /path/to/your/project/mcp mcp --env-file .env
# Env file with explicit HTTP
uvx --from /path/to/your/project/mcp mcp serve --transport http --env-file .envクロードと一緒に使う
MCP プラグインは、Claude または MCP 仕様をサポートする他の LLM で使用できます。
リモートリポジトリから実行 (推奨):
# Run the server in HTTP mode first
uvx --from \
git+https://github.com/jentic/jentic-tools.git@main#subdirectory=mcp \
mcp serve --transport http --port 8000
# Then connect claude-cli
claude-cli --mcp http://localhost:8000ローカルパスから実行 (開発):
# Run the server in HTTP mode first
uvx --from /path/to/your/project/mcp mcp serve --transport http --port 8000
# Then connect claude-cli
claude-cli --mcp http://localhost:8000発達
詳細な開発手順については、 CLAUDE.md を参照してください。
パッケージ構造
src/mcp/: メインMCPパッケージtransport/: トランスポート実装 (HTTP、stdio)mock/: 開発用のモックデータプロバイダーtools.py: ツール定義handlers.py: リクエストハンドラーmain.py: CLI エントリポイントadapters/: アダプタの実装core/: コア機能
tests/: テストスイート
テスト
# Ensure dev dependencies are installed: pdm install -G dev
pdm run testリンティングとフォーマット
pdm スクリプト経由でruff 、 black 、 isort 、 mypy使用します。
# Run all linters/formatters
pdm run lint
# Run only ruff
pdm run linterライセンス
独自仕様 - Jentic
Available Tools
3 toolsexecuteC
Perform the chosen action for the user using the provided details (if any are needed).
| Name | Required | Description | Default |
|---|---|---|---|
| execution_type | Yes | Specify whether to execute an 'operation' or a 'workflow'. | |
| inputs | Yes | The input parameters required by the operation or workflow. | |
| uuid | Yes | The UUID of the operation or workflow to execute. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states 'perform the chosen action' which implies a write/mutation operation, but doesn't disclose critical behavioral traits: whether this is synchronous/asynchronous, what permissions are required, whether it's idempotent, what happens on failure, or what the response contains. For a tool that appears to execute potentially complex operations/workflows, this is a significant gap.
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, efficient sentence that gets straight to the point without unnecessary words. However, this conciseness comes at the cost of being under-specified for a tool with three required parameters and no annotations - it could benefit from one more clarifying sentence about what gets executed.
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 3 required parameters (including a nested object), no annotations, and no output schema, the description is inadequate. It doesn't explain what types of actions can be executed, what the expected outcomes are, or provide any error handling context. The agent would struggle to use this tool effectively without trial and error.
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%, so the schema already documents all three parameters thoroughly. The description adds no parameter-specific information beyond the generic 'using the provided details' - it doesn't clarify the relationship between execution_type, uuid, and inputs, or provide examples of valid input objects. Baseline 3 is appropriate when the schema does all the heavy lifting.
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 'Perform the chosen action for the user using the provided details' is tautological - it essentially restates the tool name 'execute' without specifying what kind of actions or resources are involved. While it mentions 'chosen action' and 'provided details', it doesn't clarify whether this executes operations, workflows, scripts, or other entities, nor does it distinguish this from sibling tools like 'load_execution_info' or 'search_apis'.
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 minimal guidance - it mentions 'chosen action' and 'provided details' but gives no explicit when-to-use criteria, no prerequisites, and no comparison to alternatives like 'load_execution_info' (which presumably loads execution information rather than performing execution) or 'search_apis'. The agent must infer usage from the parameter schema alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
load_execution_infoC
Get more details about a specific action (like what information it needs from the user) before confirming you want to run it. Usually used if the action requires specific inputs. Coding Agents: To provide tools to an LLM that you have selected at runtime, use this tool to retrieve the necessary information and save it to 'jentic.json' at the root of your project.
| Name | Required | Description | Default |
|---|---|---|---|
| operation_uuids | Yes | The UUIDs of the operations to include in the configuration files. | |
| workflow_uuids | Yes | The UUIDs of the workflows to include in the configuration files. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers limited behavioral insight. It mentions retrieving information and saving to a file, but doesn't disclose critical traits like whether this is a read-only operation, if it modifies state, authentication needs, rate limits, or error handling. The description adds some context but leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but not optimally structured. The first sentence clearly states the purpose, but the second sentence adds implementation details for coding agents that may not apply to all users. The information is somewhat front-loaded but could be more focused.
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 annotations and no output schema, the description should provide more complete context. It mentions retrieving details and saving to a file, but doesn't explain what format the details take, what 'jentic.json' contains, or what happens if parameters are invalid. For a tool with 2 required parameters and mutation implications, this is inadequate.
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%, so parameters are well-documented in the schema. The description doesn't add meaningful semantic context beyond what the schema provides about operation_uuids and workflow_uuids. It mentions 'configuration files' but doesn't clarify how parameters relate to this output.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'Get more details about a specific action' which indicates its purpose, but it's vague about what 'details' means and doesn't clearly differentiate from sibling tools like 'execute' or 'search_apis'. It mentions saving to 'jentic.json' which adds specificity but confuses the core purpose with implementation details for coding agents.
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 some guidance ('Usually used if the action requires specific inputs') but lacks explicit when-to-use vs. alternatives. It doesn't clarify when to choose this over 'execute' or 'search_apis', and the coding agent note is situational rather than general usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_apisA
Search for available actions or information based on what the user wants to do (e.g., 'find Discord servers', 'send a message'). Use this first to understand what's possible.
| Name | Required | Description | Default |
|---|---|---|---|
| capability_description | Yes | Natural language description of the action needed (e.g., 'send emails', 'weather forecasting', 'natural language processing') | |
| keywords | No | Optional list of specific keywords to help narrow down the search | |
| max_results | No | Maximum number of actions to return |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool searches for actions or information but lacks details on behavioral traits such as response format, error handling, rate limits, or authentication needs. For a search tool with zero annotation coverage, this is a significant gap, though it does imply it returns results (e.g., 'to return' in the schema).
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 appropriately sized and front-loaded, with two sentences that efficiently convey purpose and usage guidelines. Every sentence earns its place by providing essential information without redundancy. It could be slightly more concise by integrating examples more seamlessly, but overall it's well-structured.
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 moderate complexity (3 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It covers purpose and usage well but lacks behavioral details like return format or error handling. Without annotations or an output schema, the description should do more to compensate, making it minimally viable but incomplete.
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%, so the schema already documents all three parameters thoroughly. The description does not add any additional meaning beyond what the schema provides, such as explaining how 'capability_description' interacts with 'keywords' or detailing search algorithms. Baseline 3 is appropriate when the schema does the heavy lifting.
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's purpose: 'Search for available actions or information based on what the user wants to do.' It provides a specific verb ('search') and resource ('available actions or information'), with examples like 'find Discord servers' and 'send a message' to illustrate usage. However, it doesn't explicitly distinguish this from sibling tools like 'execute' or 'load_execution_info', which prevents a perfect score.
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 explicit guidance on when to use this tool: 'Use this first to understand what's possible.' This clearly indicates it should be employed as an initial step to discover capabilities before invoking other tools, effectively differentiating it from siblings like 'execute' (which likely performs actions) and 'load_execution_info' (which might retrieve details).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v1.0.0- First observed
execute - First observed
load_execution_info - First observed
search_apis
TDQS
Scored across 3 tools
The tools have distinct primary purposes: 'search_apis' discovers available actions, 'load_execution_info' retrieves details for a specific action, and 'execute' performs the action. There is minor potential overlap between 'load_execution_info' and 'execute' in handling action details, but the descriptions clarify their sequential workflow roles.
The naming is mixed: 'search_apis' and 'load_execution_info' use snake_case with descriptive verbs, while 'execute' is a single verb without a noun. This inconsistency in structure (two tools follow a verb_noun pattern, one does not) reduces predictability, though the names remain readable.
With 3 tools, the count is reasonable for a server focused on action discovery and execution. It feels slightly thin but covers core workflows (search, detail retrieval, execution), avoiding bloat. A few more tools might enhance completeness, but this is a solid minimal set.
The tool set covers a basic workflow (search, load info, execute) for action-based operations, but there are notable gaps. For example, there's no tool for managing or listing previously executed actions, error handling, or status checks, which could limit agent effectiveness in more complex scenarios.
Maintenance
Related MCP Connectors
Your agents' cloud. MCP server with search, execute, packages, jobs, secrets, and integrations.
MCP Server for agents to onboard, pay, and provision services autonomously with InFlow
MCP Server for an Agent Task Marketplace
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceMCP server for Huntress API integration1MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for Agent Zone — vendor-neutral infrastructure knowledge, K8s validation, and execution templates for AI agents. 200+ articles, 10 tools, no API key required.17 npmMIT

inflow-mcpofficial
AlicenseNot gradedqualityDmaintenanceMCP Server for agents to onboard, pay, and provision services autonomously with InFlow6MIT
Grupr MCP Serverofficial
AlicenseAqualityBmaintenanceMCP server to interact with Grupr agents, enabling polling new messages, posting replies, and managing event webhooks.413 npmMIT