@settlemint/sdk-mcp 1.1.16-pr87a2b8ef → 1.1.16-pra97ca1f8

package/README.md

@@ -1,10 +1,10 @@
 <p align="center">
   <img src="https://github.com/settlemint/sdk/blob/main/logo.svg" width="200px" align="center" alt="SettleMint logo" />
-  <h1 align="center">SettleMint SDK</h1>
+  <h1 align="center">SettleMint MCP</h1>
   <p align="center">
     ✨ <a href="https://settlemint.com">https://settlemint.com</a> ✨
     <br/>
-    Integrate SettleMint into your application with ease.
+    Integrate SettleMint into your LLM with ease.
   </p>
 </p>
 
@@ -16,7 +16,7 @@
 </p>
 
 <div align="center">
-  <a href="https://console.settlemint.com/documentation/docs/using-platform/dev-tools/SDK/">Documentation</a>
+  <a href="https://console.settlemint.com/documentation">Documentation</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://www.npmjs.com/package/@settlemint/sdk-mcp">NPM</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -24,30 +24,6 @@
   <br />
 </div>
 
-## Table of Contents
-
-- [About](#about)
-- [Usage](#usage)
-  - [As a dependency in your package.json](#as-a-dependency-in-your-package.json)
-  - [Globally install the CLI](#globally-install-the-cli)
-- [GitHub Action](#github-action)
-- [Examples](#examples)
-  - [Get the version of the CLI](#get-the-version-of-the-cli)
-  - [Get help for a command](#get-help-for-a-command)
-  - [Login to the platform](#login-to-the-platform)
-  - [Creating a new project from a template](#creating-a-new-project-from-a-template)
-    - [Installing dependencies](#installing-dependencies)
-    - [Connecting to your SettleMint infrastructure](#connecting-to-your-settlemint-infrastructure)
-    - [Deploying your smart contracts and subgraphs](#deploying-your-smart-contracts-and-subgraphs)
-    - [Generating code for your dApp](#generating-code-for-your-dapp)
-    - [Start your dApp in development mode](#start-your-dapp-in-development-mode)
-  - [Creating a new project from a smart contract template](#creating-a-new-project-from-a-smart-contract-template)
-    - [Testing your smart contracts](#testing-your-smart-contracts)
-    - [Deploying your smart contracts and subgraphs](#deploying-your-smart-contracts-and-subgraphs)
-- [API Reference](#api-reference)
-- [Contributing](#contributing)
-- [License](#license)
-
 ## Introduction to Model Context Protocol (MCP)
 
 The Model Context Protocol (MCP) is a framework designed to enhance the capabilities of AI agents and large language models (LLMs) by providing structured, contextual access to external data. It acts as a bridge between AI models and a variety of data sources such as blockchain networks, external APIs, databases, and developer environments. In essence, MCP allows an AI model to pull in relevant context from the outside world, enabling more informed reasoning and interaction.
@@ -110,6 +86,23 @@ This workflow happens quickly and often behind the scenes. From a high-level per
 
 MCP consists of a few core components that work together to make the above workflow possible:
 
+```mermaid
+flowchart LR
+    A[AI Agent / LLM] --(1) request--> B{{MCP Server}}
+    subgraph MCP Server
+        B --> C1[Blockchain Connector]
+        B --> C2[API Connector]
+        B --> C3[File System Connector]
+    end
+    C1 -- fetch/query --> D[(Blockchain Network)]
+    C2 -- API call --> E[(External API/Data Source)]
+    C3 -- read/write --> F[(Local File System)]
+    D -- data --> C1
+    E -- data --> C2
+    F -- file data --> C3
+    B{{MCP Server}} --(2) formatted data--> A[AI Agent / LLM]
+```
+
 - MCP Server: This is the central service or daemon that runs and listens for requests from AI agents. It can be thought of as the brain of MCP that coordinates everything. The MCP server is configured to know about various data sources and how to connect to them. In practice, you might run an MCP server process locally or on a server, and your AI agent will communicate with it via an API (like HTTP requests, RPC calls, or through an SDK).
 - MCP SDK / Client Library: To simplify usage, MCP provides SDKs in different programming languages. Developers include these in their AI agent code. The SDK handles the communication details with the MCP server, so a developer can simply call functions or methods (like mcp.getData(...)) without manually constructing network calls. The SDK ensures requests are properly formatted and sends them to the MCP server, then receives the response and hands it to the AI program.
 - Connectors / Adapters: These are modules or plugins within the MCP server that know how to talk to specific types of external systems. One connector might handle blockchain interactions (with sub-modules for Ethereum, Hyperledger, etc.), another might handle web APIs (performing HTTP calls), another might manage local OS operations (file system access, running shell commands). Each connector understands a set of actions and data formats for its domain. Connectors make MCP extensible - new connectors can be added to support new systems or protocols.
@@ -128,6 +121,32 @@ By leveraging MCP, SettleMint enables scenarios where:
 - Autonomous agents can manage blockchain infrastructure tasks (deploying contracts, adjusting configurations) without human intervention, guided by AI decision-making.
 - Developers using SettleMint can integrate advanced AI functionalities into their blockchain applications with relatively little effort, because MCP handles the heavy lifting of connecting the two worlds.
 
+```mermaid
+sequenceDiagram
+    participant AI as AI Model (Agent)
+    participant MCP as MCP Server
+    participant Chain as The Graph / Portal / Node
+    participant API as External API
+
+    AI->>MCP: (1) Query request (e.g., get contract state)
+    Note over AI,MCP: AI asks MCP for on-chain data
+    MCP-->>AI: (2) Acknowledgement & processing
+
+    MCP->>Chain: (3) Fetch data from blockchain
+    Chain-->>MCP: (4) Return contract state
+
+    MCP->>API: (5) [Optional] Fetch related off-chain data
+    API-->>MCP: (6) Return external data
+
+    MCP-->>AI: (7) Send combined response
+    Note over AI,MCP: AI receives on-chain data (and any other context)
+
+    AI->>MCP: (8) Action request (e.g., execute transaction)
+    MCP->>Chain: (9) Submit transaction to blockchain
+    Chain-->>MCP: (10) Return tx result/receipt
+    MCP-->>AI: (11) Confirm action result
+```
+
 In summary, SettleMint's version of MCP extends their platform's capabilities, allowing for AI-driven blockchain operations. This combination brings together the trust and transparency of blockchain with the adaptability and intelligence of AI.
 
 ### Capabilities and Features
@@ -162,12 +181,12 @@ Suppose you are a developer working on a blockchain project, and you want to use
 For instance, you might use a command (via a CLI or an npm script) to start an MCP server that is pointed at your project directory and connected to the SettleMint platform. An example command could be:
 
 ```sh
-bunx @settlemint/sdk-mcp@latest --path=/Users/llm/asset-tokenization-kit/ --pat=sm_pat_xxx
+npx -y @settlemint/sdk-mcp@latest --path=/Users/llm/asset-tokenization-kit/ --pat=sm_pat_xxx
 ```
 
 Here's what this command does:
 
-- bunx is used to execute the latest version of the @settlemint/sdk-mcp package without needing a separate install (similar to how npx works for npm packages).
+- npx is used to execute the latest version of the @settlemint/sdk-mcp package without needing a separate install.
 - --path=/Users/llm/asset-tokenization-kit/ specifies the local project directory that the MCP server will have context about. This could allow the AI to query files or code in that directory through MCP and have access to the environment settings from `settlemint connect`
 - --pat=sm_pat_xxx provides a Personal Access Token (PAT) for authenticating with SettleMint's services. This token (masked here as xxx) is required for the MCP server to connect to the SettleMint platform on your behalf.
 
@@ -180,7 +199,7 @@ After running this command, you would have a local MCP server up and running, co
 
 This greatly enhances a development workflow by making the AI an active participant that can fetch and act on real information, rather than just being a passive code suggestion tool.
 
-### Using the SettleMint MPC in Cursor
+#### Using the SettleMint MPC in Cursor
 
 Cursor (0.47.0 and up) provides a global `~/.cursor/mcp.json` file where you can configure the SettleMint MCP server. Point the path to the folder of your program, and set your personal access token.
 
@@ -190,8 +209,53 @@ Cursor (0.47.0 and up) provides a global `~/.cursor/mcp.json` file where you can
 {
   "mcpServers": {
     "settlemint": {
-      "command": "bunx",
+      "command": "npx",
+      "args": [
+        "-y",
+        "@settlemint/sdk-mcp@latest",
+        "--path=/Users/llm/asset-tokenization-kit/",
+        "--pat=sm_pat_xxx"
+      ]
+    }
+  }
+}
+```
+
+Open Cursor and navigate to Settings/MCP. You should see a green active status after the server is successfully connected.
+
+#### #### Using the SettleMint MPC in Claude Desktop
+
+Open Claude desktop and navigate to Settings. Under the Developer tab, tap Edit Config to open the configuration file and add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "settlemint": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@settlemint/sdk-mcp@latest",
+        "--path=/Users/llm/asset-tokenization-kit/",
+        "--pat=sm_pat_xxx"
+      ]
+    }
+  }
+}
+```
+
+Save the configuration file and restart Claude desktop. From the new chat screen, you should see a hammer (MCP) icon appear with the new MCP server available.
+
+#### #### Using the SettleMint MPC in Cline
+
+Open the Cline extension in VS Code and tap the MCP Servers icon. Tap Configure MCP Servers to open the configuration file and add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "settlemint": {
+      "command": "npx",
       "args": [
+        "-y",
         "@settlemint/sdk-mcp@latest",
         "--path=/Users/llm/asset-tokenization-kit/",
         "--pat=sm_pat_xxx"
@@ -201,6 +265,51 @@ Cursor (0.47.0 and up) provides a global `~/.cursor/mcp.json` file where you can
 }
 ```
 
+Save the configuration file. Cline should automatically reload the configuration. You should see a green active status after the server is successfully connected.
+
+#### #### Using the SettleMint MPC in Windsurf
+
+Open Windsurf and navigate to the Cascade assistant. Tap on the hammer (MCP) icon, then Configure to open the configuration file and add the following configuration:
+
+
+```json
+{
+  "mcpServers": {
+    "settlemint": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@settlemint/sdk-mcp@latest",
+        "--path=/Users/llm/asset-tokenization-kit/",
+        "--pat=sm_pat_xxx"
+      ]
+    }
+  }
+}
+```
+
+Save the configuration file and reload by tapping Refresh in the Cascade assistant. You should see a green active status after the server is successfully connected.
+
+### AI-Driven Blockchain Application or Agent
+
+To illustrate a real-world scenario, consider an AI-driven Decentralized Finance (DeFi) application. In DeFi, conditions change rapidly (prices, liquidity, user activity), and it's critical to respond quickly.
+
+Scenario: You have a smart contract that manages an automatic liquidity pool. You want to ensure it remains balanced - if one asset's price drops or the pool becomes unbalanced, you'd like to adjust fees or parameters automatically.
+
+Using MCP in this scenario:
+
+1.	An AI agent monitors the liquidity pool via MCP. Every few minutes, it requests the latest pool balances and external price data (from on-chain or off-chain oracles) through the MCP server.
+2.	MCP fetches the latest state from the blockchain (pool reserves, recent trades) and maybe calls an external price API for current market prices, then returns that data to the AI.
+3.	The AI analyzes the data. Suppose it finds that Asset A's proportion in the pool has drastically increased relative to Asset B (perhaps because Asset A's price fell sharply).
+4.	The AI decides that to protect the pool, it should increase the swap fee temporarily (a common measure to discourage arbitrage draining the pool).
+5.	Through MCP, the AI calls a function on the smart contract to update the fee parameter. The MCP's blockchain connector handles creating and sending the transaction to the network via SettleMint's infrastructure.
+6.	The transaction is executed on-chain, adjusting the fee. MCP catches the success response and any relevant event (like an event that the contract might emit for a fee change).
+7.	The AI receives confirmation and can log the change or inform administrators that it took action.
+
+In this use case, MCP enabled the AI to be a real-time guardian of the DeFi contract. Without MCP, the AI would not have access to the live on-chain state or the ability to execute a change. With MCP, the AI becomes a powerful autonomous agent that ensures the blockchain application adapts to current conditions.
+
+This is just one example. AI-driven blockchain applications could range from automatic NFT marketplace management, to AI moderators for DAO proposals, to intelligent supply chain contracts that react to sensor data. MCP provides the pathway for these AI agents to communicate and act where it matters - on the blockchain and connected systems.
+
 ## Contributing
 
 We welcome contributions from the community! Please check out our [Contributing](https://github.com/settlemint/sdk/blob/main/.github/CONTRIBUTING.md) guide to learn how you can help improve the SettleMint SDK through bug reports, feature requests, documentation updates, or code contributions.

package/dist/mcp.js

@@ -55021,7 +55021,7 @@ class Protocol {
     Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
   }
   _onrequest(request) {
-    var _a, _b;
+    var _a, _b, _c;
     const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== undefined ? _a : this.fallbackRequestHandler;
     if (handler === undefined) {
       (_b = this._transport) === null || _b === undefined || _b.send({
@@ -55036,7 +55036,11 @@ class Protocol {
     }
     const abortController = new AbortController;
     this._requestHandlerAbortControllers.set(request.id, abortController);
-    Promise.resolve().then(() => handler(request, { signal: abortController.signal })).then((result) => {
+    const extra = {
+      signal: abortController.signal,
+      sessionId: (_c = this._transport) === null || _c === undefined ? undefined : _c.sessionId
+    };
+    Promise.resolve().then(() => handler(request, extra)).then((result) => {
       var _a2;
       if (abortController.signal.aborted) {
         return;
@@ -62578,7 +62582,7 @@ var {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "1.1.16-pr87a2b8ef",
+  version: "1.1.16-pra97ca1f8",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -62619,9 +62623,9 @@ var package_default = {
   dependencies: {
     "@graphql-tools/load": "8.0.17",
     "@graphql-tools/url-loader": "8.0.29",
-    "@modelcontextprotocol/sdk": "1.6.1",
-    "@settlemint/sdk-js": "1.1.16-pr87a2b8ef",
-    "@settlemint/sdk-utils": "1.1.16-pr87a2b8ef",
+    "@modelcontextprotocol/sdk": "1.7.0",
+    "@settlemint/sdk-js": "1.1.16-pra97ca1f8",
+    "@settlemint/sdk-utils": "1.1.16-pra97ca1f8",
     "@commander-js/extra-typings": "11.1.0",
     commander: "11.1.0",
     zod: "3.24.2"
@@ -68290,4 +68294,4 @@ await main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=0A9F507F237A8C2D64756E2164756E21
+//# debugId=6EAD499DC66F7D8664756E2164756E21