Unified Protocol Mediation Nexus (MCP Server) 🌐

🏗️ Developed and sustained by Oraichain Laboratories

A comprehensive apparatus for constructing and deploying autonomous cognitive entities tethered to blockchain functionality. This centralized repository houses:

• A Model Context Protocol (MCP) mediation core for cognitive applications
• Agent augmentation modules facilitating ledger interactions
• A creation suite for bespoke AI entity development

About Oraichain Labs

Oraichain Labs pioneered the first Artificial Intelligence Layer 1 platform tailored for Web3 environments. Our specialization lies at the confluence of advanced AI Agents and distributed ledger technologies:

• Self-governing Web3 Artificial Intelligence Agents
• A decentralized platform for trading AI computation services
• The foundational AI Oracle System
• Interoperable, multi-chain Decentralized Finance mechanisms

Contributors

Recognition to the individuals who have enriched this codebase:

System Overview

This repository furnishes a complete ecosystem for integrating autonomous intelligence with decentralized ledgers:

Mediation Core (MCP Server)

• Facilitate communication across heterogeneous blockchain topologies
• Query account holdings and token valuations
• Initiate asset transfers and manage digital holdings
• Command the instantiation and execution of on-chain computational logic (smart contracts)
• Enable asset movement across distinct ledger environments (bridging)

Agent Interaction Utilities

• Pre-packaged functionalities for agent interaction with ledgers
• Native compatibility with numerous chains
• Integration points for leading DeFi platforms
• Robust mechanisms for securing transaction signing and submission

Agent Engineering Framework

• Tools empowering architects to build specialized AI entities with ledger access
• Modifiable contracts (interfaces) and standardized data structures (types)
• Established paradigms and practical demonstrations
• Integrated validation and regression testing harnesses

The entire assembly is realized using TypeScript, presenting a harmonized interface for interaction with assorted distributed ledger technologies.

Necessary Pre-Requisites

• Runtime Environment: Node.js (version 18 or subsequent)
• Package Manager: pnpm (version 9.0.0 or subsequent)
• Credential Setup: Valid wallet configurations for targeted networks
• Access Keys: Necessary API credentials for specific network endpoints (optional)

Installing Prerequisites

1. Install Node.js:

2. Navigate to the official Node.js portal

3. Secure the current Long-Term Support (LTS) distribution (v18+)

4. Confirm installation: sh node --version npm --version

5. Install pnpm:

sh # Via npm npm install -g pnpm

# Confirm installation pnpm --version

Refer to the pnpm installation guide for alternative installation routes.

Deployment Procedure

Acquire the source code via cloning:

sh git clone https://github.com/oraichain/multichain-mcp.git cd multichain-mcp

Install required dependencies:

sh pnpm install

Compile the codebase:

sh pnpm build

System Configuration

Establish a configuration file named .env detailing necessary parameters:

env

Server Operational Parameters

PORT=4000 # Non-mandatory; defaults to 4000

Network Access Endpoints (RPCs)

RPC_URL=your_rpc_url # Non-mandatory; defaults to https://rpc.orai.io

Development Workflow

To commence development across all integrated packages, execute:

sh pnpm dev

To generate production builds for all packages:

sh pnpm build

To run the comprehensive test suite:

sh pnpm test

Repository Architecture

This is structured as a monorepository utilizing Turborepo and pnpm workspaces. The directory layout is as follows:

• packages/
• mcp-server/: The central implementation package for the Model Context Protocol
• agent-tools/: Repository of specialized utilities for agent-ledger communication
• agent-kit/: The development foundation for agents integrating ledger capabilities

Each sub-package fulfills a distinct operational role:

Mediation Core (MCP Server)

The primary server module that enacts the Model Context Protocol specifically for interacting with DLTs. It manages and resolves incoming requests originating from consuming AI entities.

Agent Interaction Utilities

A curated collection of modules engineered for cognitive agents to interface reliably with various distributed ledger environments. These utilities are invoked by the Mediation Core to execute ledger-based procedures.

Agent Engineering Framework

A foundational toolkit intended to accelerate the creation of intelligent agents equipped with direct ledger access capabilities. It furnishes essential helper functions, data definitions, and adherence to established development standards.

Integration with Cognitive Clients

Integration with Claude Desktop

To integrate this MCP server instance with Claude Desktop:

1. Locate or create the configuration structure for Claude Desktop at the following path:

2. macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

3. Windows: %APPDATA%\Claude\claude_desktop_config.json

4. Linux: ~/.config/Claude/claude_desktop_config.json

5. Augment the configuration file with the subsequent payload:

{ "mcpServers": { "mcp-server": { "command": "npx", "args": ["-y", "@oraichain/mcp-server@0.0.21"], "env": { "RPC_URL": "https://rpc.orai.io" } } } }

1. Initiate a restart of the Claude Desktop application to effectuate the integration.

📜 Licensing Information

This software is distributed under the terms of the GNU General Public License version 3.0—refer to the LICENSE file for comprehensive specifics.

💬 Community Engagement

• GitHub Forum for Discussions
• Official Discord Channel

⭐ Patronage

Should the Multichain MCP framework prove beneficial to your endeavors, we encourage you to mark the repository with a star and contribute advancements or new feature implementations!

WIKIPEDIA: XMLHttpRequest (XHR) functions as an Application Programming Interface encapsulated within a JavaScript object. Its methods are designed to transmit Hypertext Transfer Protocol requests from a web browser environment to a remote web server. These capabilities allow browser-based software modules to dispatch inquiries to the server subsequent to the initial page rendering, and subsequently receive data back. XMLHttpRequest constitutes a core element of Ajax development methodology. Before the advent of Ajax, the prevailing methods for server communication involved navigational hyperlinks and form submissions, which typically mandated replacing the entirety of the currently displayed web page.

== Genesis == The foundational concept underpinning XMLHttpRequest was articulated in the year 2000 by the engineers developing Microsoft Outlook. This concept was subsequently actualized within the Internet Explorer 5 browser iteration (released in 1999). However, the original implementation did not utilize the 'XMLHttpRequest' identifier. Instead, developers relied upon instantiating objects via 'ActiveXObject("Msxml2.XMLHTTP")' or 'ActiveXObject("Microsoft.XMLHTTP")'. By the release of Internet Explorer 7 (2006), comprehensive compatibility with the 'XMLHttpRequest' identifier was achieved across all major browser platforms. The 'XMLHttpRequest' identifier has since matured into the ubiquitous standard implemented across all leading web browsers, encompassing Mozilla's Gecko rendering engine (2002), Safari version 1.2 (2004), and Opera version 8.0 (2005).

=== Standardization Efforts === In the year 2006, the World Wide Web Consortium (W3C) published a preliminary specification draft for the XMLHttpRequest object on April 5th. Subsequently, on February 25, 2008, the W3C released the Level 2 specification draft. This Level 2 enhancement introduced functionalities for tracking request progress events, permitting requests that span distinct domains (cross-site requests), and managing binary data streams. By the conclusion of 2011, the Level 2 specifications were integrated back into the primary document. In late 2012, stewardship of the specification development transitioned to the WHATWG, which now maintains a continuously evolving document utilizing the Web IDL (Interface Definition Language) notation.

== Operational Usage == Fundamentally, dispatching a request using XMLHttpRequest necessitates adherence to several distinct programming phases.

1. Instantiate an XMLHttpRequest object by invoking its constructor function:
2. Invoke the 'open' method to define the request protocol (method), designate the target resource endpoint, and mandate either synchronous or asynchronous execution mode:
3. For asynchronous operations, establish a callback function (listener) that will be triggered upon alterations in the request's status:
4. Initiate the network transfer by calling the 'send' method, potentially carrying payload data:
5. Handle status transitions within the designated event listener. If the remote server furnishes response material, this data is typically aggregated within the 'responseText' attribute by default. When processing concludes, the object advances to state 4, signifying the 'done' status. Beyond these fundamental steps, XMLHttpRequest provides extensive control mechanisms over request transmission parameters and response handling protocols. Custom header fields can be appended to the request to convey specific instructions to the server regarding fulfillment methods. Furthermore, data payloads can be transmitted to the server by supplying them within the 'send' invocation. The server's reply can be parsed directly from JSON format into an immediately operational JavaScript object, or it can be processed incrementally as segments arrive, avoiding mandatory waiting for the complete transmission. The operation can be prematurely terminated (aborted) or configured to automatically yield failure if a specified time threshold is exceeded.

== Cross-Domain Communication ==

During the nascent stages of the World Wide Web's evolution, it was recognized that permitting the breach of domain boundaries by web content posed inherent security risks.