Chronosは、Stellarブロックチェーン向けにカスタマイズされたモデルコンテキストプロトコル（MCP）サーバーであり、Claude DesktopなどのAIアプリケーションとの統合に特化して設計されています。Chronosは、Stellarネットワークとの効率的なインタラクションを可能にするオンチェーンツールをAIアシスタントに提供します。
Chronos MCP は次の機能を提供します。
**Stellar ウォレットに接続:**秘密キーを使用してウォレットに安全に接続します。
ウォレット トークンの一覧表示: Stellar ウォレットに保持されているすべてのトークンを取得して一覧表示します。
残高照会: XLM やその他の資産のリアルタイムの残高を取得します。
資金の送金: Stellar ウォレット間の送金を簡単に開始できます。
Chronos は拡張可能に構築されており、標準の Node.js パッケージとして動作するため、base-mcp などの他の MCP サーバーと同様に簡単に展開、インストール、統合できます。
Related MCP server: AMOCA Solana MCP Server
Stellar 統合: Horizon API を介して Stellar メインネットと完全に対話します。
簡単なデプロイメント: npm を使用して Chronos を公開およびインストールします。
Claude Desktop の互換性: MCP サーバー構成を更新することで、Claude Desktop とシームレスに統合します。
**拡張可能なアーキテクチャ:**将来の機能強化や新しいツールの統合に対応するように設計されています。
Node.js (v14以上)
npm
Stellar ウォレットの認証情報（接続用の秘密鍵）
Stellarネットワークとやり取りするためのインターネット接続
Chronos をグローバルにインストールします。
npm install -g chronos-mcpまたは、npx で直接使用します。
npx chronos-mcp@latestリポジトリをクローンします。
git clone https://github.com/yourusername/chronos-mcp.git
cd chronos-mcp依存関係をインストールします:
npm installプロジェクトをビルドします。
npm run build(オプション) アクセスを容易にするためにグローバルにリンクします。
npm linkDocker を使用して Chronos MCP を実行することもできます。
Docker イメージをビルドします。
docker build -t chronos-mcp .コンテナを実行します。
docker run -it --rm chronos-mcpDocker Compose のセットアップや Claude Desktop との統合など、Chronos MCP で Docker を使用する詳細な手順については、『 Docker 使用ガイド』を参照してください。
Docker セットアップがローカルで動作するかどうかをテストするには、 「Docker テストガイド」の手順に従ってください。このガイドには、Docker イメージの構築、コンテナの実行、機能のテストに関する手順が記載されています。
Chronos MCPは、特にStellar秘密鍵のような機密情報の設定に環境変数を使用します。このプロジェクトでは、開発中に.envファイルから環境変数を読み込むためにdotenv使用しています。
環境変数を構成するには:
プロジェクト ルートに.envファイルを作成します。
STELLAR_SECRET_KEY=your_stellar_secret_key
STELLAR_NETWORK=mainnetこれらの変数は、アプリケーションの起動時に自動的に読み込まれます。
Docker を使用する場合、環境変数はいくつかの方法で提供できます。
--env-fileフラグの使用: docker run -it --rm --env-file .env chronos-mcp
docker-compose.yml でenv_fileディレクティブを使用する
-eフラグを使用して個々の変数を設定する: docker run -it --rm -e STELLAR_SECRET_KEY=your_key chronos-mcp
Claude Desktop で Chronos を使用するには、次の場所にある Claude Desktop 構成ファイルを更新します。
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
Claude Desktop のサンプル構成:
{
<<<<<<< HEAD
"mcpServers": {
"stellar": {
"command": "npx",
"args": ["chronos-mcp@latest"],
"env": {
"STELLAR_NETWORK": "mainnet",
"STELLAR_SECRET_KEY": "your_stellar_secret_key"
},
"disabled": false,
"autoApprove": []
}
}
}Claude Desktop と Docker を統合するには、以下を使用できます。
{
"mcpServers": {
"stellar": {
"command": "docker",
"args": ["run", "-i", "--rm", "--env-file", "/path/to/your/.env", "chronos-mcp"],
"env": {
"STELLAR_NETWORK": "mainnet"
},
"disabled": false,
"autoApprove": []
=======
"mcpServers": {
"stellar": {
"command": "npx",
"args": [
"chronos-mcp@latest"
],
"env": {
"STELLAR_NETWORK": "mainnet",
"STELLAR_SECRET_KEY": "XXXX"
},
"disabled": false,
"autoApprove": []
}
>>>>>>> b2501026b3b5ef4c512fceaf340f53b5102a57f9
}
}Chronos MCP は、MCP インターフェースを通じて次のツールを公開します。
秘密鍵を使用して Stellar ウォレットに接続します。
コマンド例:
「秘密鍵______を使用してウォレットを接続します」
指定された Stellar ウォレット内のすべてのトークンと資産を一覧表示します。
コマンド例:
「ウォレットトークンを一覧表示する」
XLM およびその他の資産の残高を取得します。
コマンド例:
「現在のXLM残高はいくらですか？」
ウォレットから別の Stellar ウォレットに資金を転送します。
パラメータ:
secretKey : ウォレットの秘密鍵。
destinationAddress : 受信者のウォレットアドレス。
amount : 送金する金額。
asset(オプション) : 転送する資産 (デフォルトは XLM)。
コマンド例:
「0.5 XLMを[送信先ウォレットアドレス]に送金する」
Chronos MCP をローカルでテストするには:
npm testこれにより、プロジェクトのテスト スイートが実行され、サーバーが期待どおりに動作していることが検証されます。
Dockerのセットアップをローカルでテストするには、詳細な手順についてはDockerテストガイドを参照してください。ガイドの内容は以下のとおりです。
Dockerイメージの構築
Docker Composeでコンテナを実行する
コンテナの機能のテスト
よくある問題のトラブルシューティング
付属のtest-client.jsスクリプトを使用して Docker コンテナをテストすることもできます。
node test-client.jsこのスクリプトは、単純な MCP 要求を Docker コンテナに送信し、応答を表示します。
Chronos MCPは標準のNode.jsパッケージとして機能するように設計されており、npmに公開できます。公開後（例： npm publish ）、Chronosは他のMCPサーバーと同様に、グローバルにインストールしたり、npx経由で使用したりできます。
実稼働環境での展開では、自動再起動と監視のために、Chronos をシステム サービス (systemd、launchd などを使用) にラップすることを検討してください。
Chronosは拡張性を考慮して構築されています。新しいツールを追加するには：
src/toolsフォルダに新しいディレクトリを作成します。
ツールを実装します ( index.ts 、 schemas.ts 、 handlers.tsを含めます)。
ツールをsrc/tools/index.tsにエクスポートします。
ツールのドキュメントと例を README に更新します。
新しいツールが正しく動作することを確認するためのテストを記述します。
このプロジェクトはMIT ライセンスに基づいてライセンスされています。
貢献を歓迎します！問題の報告、プルリクエストの送信、その他の貢献手順に関するガイドラインについては、 CONTRIBUTING.md を参照してください。
──────────────────────────────── この README は Chronos MCP 専用に調整されており、Node.js パッケージとしての展開、Claude Desktop との統合、および Stellar ブロックチェーンと対話するための包括的な機能セットについて概説しています。
Connect to a Stellar wallet using secret key
| Name | Required | Description | Default |
|---|---|---|---|
| secretKey | Yes | Stellar wallet secret key |
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 states the tool connects using a secret key but doesn't describe what happens after connection (e.g., session persistence, error handling, or security implications like key storage). For a tool handling sensitive authentication with no annotation coverage, this is a significant gap in transparency.
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 with zero waste. It is front-loaded with the core action and resource, making it easy to parse. Every word earns its place by specifying the tool's purpose clearly 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?
Given the complexity of wallet connection (involving authentication and potential security concerns), no annotations, no output schema, and a single parameter, the description is incomplete. It doesn't explain what the tool returns (e.g., success status, wallet details) or behavioral aspects like error cases, leaving gaps for an AI agent to understand the tool fully.
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, with the parameter 'secretKey' documented as 'Stellar wallet secret key'. The description adds no additional meaning beyond this, as it only repeats that connection uses a secret key. Baseline 3 is appropriate since the schema does the heavy lifting, but the description doesn't compensate or enhance parameter understanding.
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 ('Connect to') and target resource ('a Stellar wallet'), specifying it uses a secret key. It distinguishes from sibling tools like get_balances or transfer_funds by focusing on authentication rather than querying or transactions. However, it doesn't explicitly differentiate from potential other connection methods (e.g., via public key or mnemonic), keeping it from 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?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a secret key), when not to use it (e.g., if already connected), or how it relates to sibling tools like get_balances. The description implies usage for wallet connection but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get balances for all tokens in a Stellar wallet
| Name | Required | Description | Default |
|---|---|---|---|
| publicKey | Yes | Stellar wallet public key |
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 states the tool's function but lacks critical details: it doesn't specify if this is a read-only operation (implied but not explicit), potential rate limits, authentication needs, error conditions, or what the output format looks like (e.g., JSON structure). This leaves significant gaps for safe and effective use.
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 front-loads the core purpose ('Get balances for all tokens in a Stellar wallet'). There is no wasted verbiage or redundancy, making it easy 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 lack of annotations and output schema, the description is incomplete for a tool that interacts with financial data. It doesn't explain return values (e.g., balance amounts, token details), error handling, or dependencies on other tools like 'connect_wallet'. For a tool with no structured output documentation, this leaves the agent under-informed.
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%, with the single parameter 'publicKey' clearly documented in the schema. The description adds no additional parameter semantics beyond what's in the schema (e.g., format examples, validation rules, or context about the wallet). This meets the baseline for high schema coverage but doesn't enhance understanding.
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 ('Get balances') and resource ('all tokens in a Stellar wallet'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_tokens' (which might list available tokens vs. getting balances), leaving room for potential confusion.
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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a connected wallet via 'connect_wallet'), exclusions, or comparisons to siblings like 'list_tokens' or 'transfer_funds', leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all tokens in a Stellar wallet
| Name | Required | Description | Default |
|---|---|---|---|
| publicKey | Yes | Stellar wallet public key |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It doesn't disclose whether this is a read-only operation, requires authentication, has rate limits, or what the output format might be. While 'List' suggests a safe read, the lack of details on permissions or response structure is a significant gap for a tool with zero annotation coverage.
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 front-loads the core purpose without unnecessary words. Every part earns its place by directly stating the tool's function, making it highly concise and well-structured for quick understanding.
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 lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what 'tokens' entail (e.g., types, formats), authentication needs, or response behavior. For a tool with one parameter but no structured safety or output info, more context is needed to guide the agent adequately.
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%, with the parameter 'publicKey' fully documented in the schema. The description adds no additional meaning beyond implying it's for a Stellar wallet, which is already clear from the schema. This meets the baseline of 3, as the schema handles the heavy lifting without extra value from the description.
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 ('List') and resource ('tokens in a Stellar wallet'), making the purpose immediately understandable. It distinguishes from siblings like 'get_balances' by focusing specifically on tokens rather than general balances. However, it doesn't specify whether this includes all token types or just specific ones, keeping it from 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?
No explicit guidance is provided on when to use this tool versus alternatives like 'get_balances' or 'connect_wallet'. The description implies usage for token listing but doesn't mention prerequisites (e.g., needing a connected wallet) or exclusions. This leaves the agent to infer context without clear direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Transfer funds to another Stellar wallet
| Name | Required | Description | Default |
|---|---|---|---|
| secretKey | Yes | Source wallet secret key | |
| destinationAddress | Yes | Destination wallet public key | |
| amount | Yes | Amount to transfer | |
| asset | No | Asset to transfer (defaults to XLM) |
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 states the tool performs a fund transfer but fails to mention critical aspects such as whether this is a destructive/mutative operation, authentication requirements (implied by 'secretKey' but not explicitly stated), potential rate limits, transaction fees, or error handling. This leaves significant gaps in understanding the tool's 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, direct sentence that efficiently conveys the core purpose without any unnecessary words or fluff. It is appropriately sized and front-loaded, 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 complexity of a financial transaction tool with no annotations and no output schema, the description is insufficient. It lacks details on return values, error conditions, security implications, or operational constraints, making it incomplete for safe and effective use by an AI agent.
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 schema description coverage is 100%, so the input schema already documents all parameters thoroughly (e.g., 'secretKey' as source wallet secret key, 'destinationAddress' as destination public key). The description adds no additional semantic context beyond what's in the schema, such as format details or examples, resulting in a baseline score of 3.
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 ('transfer funds') and target resource ('to another Stellar wallet'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'connect_wallet' or 'get_balances', which are distinct operations, so it doesn't reach the highest score for sibling differentiation.
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 no guidance on when to use this tool versus alternatives or any contextual prerequisites. It lacks explicit instructions on usage scenarios, exclusions, or comparisons with sibling tools like 'list_tokens', leaving the agent to infer usage based on the tool name alone.
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.
connect_walletget_balanceslist_tokenstransfer_fundsScored across 4 tools
Each tool has a clearly distinct purpose: connect_wallet handles authentication, get_balances retrieves token balances, list_tokens enumerates available tokens, and transfer_funds performs transactions. There is no overlap or ambiguity between these functions.
All tools follow a consistent verb_noun pattern (connect_wallet, get_balances, list_tokens, transfer_funds) with clear, descriptive names. The naming convention is uniform and predictable throughout the set.
Four tools are reasonable for a Stellar wallet server, covering core operations like connection, balance checking, token listing, and transfers. However, the scope feels slightly thin as it lacks tools for advanced wallet management (e.g., transaction history, account details).
The tools cover essential wallet operations: authentication, balance retrieval, token listing, and fund transfers. Minor gaps exist, such as no tools for viewing transaction history or managing wallet settings, but agents can perform basic workflows without significant dead ends.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
The OpenZeppelin Stellar Contracts MCP server generates secure smart contracts for the Stellar blockchain based on OpenZeppelin templates. It integrates with AI assistants to automatically enforce OpenZeppelin's security best practices, style rules, and standards at every prompt, enabling developers to create production-ready Fungible Token, Non-Fungible Token, and Stablecoin contracts through AI-driven workflows.
The Telnyx MCP server is an official implementation of the Model Context Protocol that enables AI clients (like Claude Desktop, Cursor, and OpenAI Agents) to interact with Telnyx's telephony, messaging, and AI assistant APIs. It provides comprehensive capabilities including making and managing phone calls, sending SMS/MMS messages, purchasing and configuring phone numbers, creating AI assistants with custom instructions, managing cloud storage buckets, scraping and embedding website content, and handling integration secrets. The server exists as both a local implementation and a remotely hosted version, allowing developers to integrate real-world communication infrastructure directly into AI applications.
