Chronos 是一款专为 Stellar 区块链量身定制的模型上下文协议 (MCP) 服务器，专为与 Claude Desktop 及类似的 AI 应用程序集成而设计。Chronos 为您的 AI 助手提供链上工具，从而简化与 Stellar 网络的交互。
Chronos MCP 提供以下功能：
**连接到恒星钱包：**使用密钥安全地连接到您的钱包。
**列出钱包代币：**检索并列出 Stellar 钱包中持有的所有代币。
**查询余额：**获取您的 XLM 和其他资产的实时余额。
**转移资金：**轻松地在 Stellar 钱包之间发起转账。
Chronos 具有可扩展性，可作为标准 Node.js 包运行，因此可以轻松部署、安装和集成 - 类似于其他 MCP 服务器（如 base-mcp）。
Related MCP server: AMOCA Solana MCP Server
**Stellar 集成：**通过 Horizon API 与 Stellar 主网完全交互。
**轻松部署：**使用 npm 发布和安装 Chronos。
**Claude Desktop 兼容性：**通过更新 MCP 服务器配置与 Claude Desktop 无缝集成。
**可扩展架构：**专为未来的增强和新工具集成而设计。
Node.js（v14 或更高版本）
npm
恒星钱包凭证（连接密钥）
互联网连接与恒星网络交互
全局安装 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 link您还可以使用 Docker 运行 Chronos MCP：
构建 Docker 镜像：
docker build -t chronos-mcp .运行容器：
docker run -it --rm chronos-mcp有关将 Docker 与 Chronos MCP 结合使用的更多详细说明，包括 Docker Compose 设置以及与 Claude Desktop 的集成，请参阅Docker 使用指南。
要测试您的 Docker 设置是否在本地运行，请按照Docker 测试指南中的分步说明进行操作。本指南包含有关构建 Docker 映像、运行容器以及测试其功能的说明。
Chronos MCP 使用环境变量进行配置，尤其是像 Stellar 密钥这样的敏感信息。该项目在开发过程中使用dotenv从.env文件加载环境变量。
配置环境变量：
在项目根目录中创建一个.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
要将 Chronos 与 Claude Desktop 一起使用，请更新位于以下位置的 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": []
}
}
}对于 Docker 与 Claude Desktop 的集成，您可以使用：
{
"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该脚本向 Docker 容器发送一个简单的 MCP 请求并显示响应。
Chronos MCP 旨在作为标准的 Node.js 软件包运行，并可发布到 npm。发布后（例如通过npm publish ），Chronos 可以全局安装或通过 npx 使用，就像任何其他 MCP 服务器一样。
对于生产部署，考虑将 Chronos 包装在系统服务中（使用 systemd、launchd 等）以实现自动重启和监控。
Chronos 在构建时充分考虑了可扩展性。要添加新工具，请执行以下操作：
在src/tools文件夹中创建一个新目录。
实现您的工具（包括index.ts 、 schemas.ts和handlers.ts ）。
在src/tools/index.ts中导出您的工具。
使用您的工具的文档和示例更新 README。
编写测试以确保您的新工具正常运行。
该项目已获得MIT 许可。
欢迎贡献代码！请参阅CONTRIBUTING.md文件，了解如何报告问题、提交拉取请求以及其他贡献说明。
────────────────────────────────── 本自述文件专为 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.
