# Akash Model Context Server Interface **Akash MCP Gateway** represents a robust TypeScript framework built to conform to the Model Context Protocol, facilitating seamless agent interaction with the underlying Akash decentralized compute ecosystem. [](https://opensource.org/licenses/Apache-2.0) [](https://x.com/akashnet_ 'Follow Akash Network on X') [](https://discord.gg/akash 'Join Akash Discord')

Development Status Notice

This utility is presently undergoing active refinement; not all anticipated tools have reached final implementation. We are actively augmenting the toolset and enhancing server stability. Community contributions are highly welcomed! Refer to CONTRIBUTING.md for contribution guidelines.

Functional Summary

This server acts as the critical intermediary layer, empowering sophisticated AI constructs to programmatically engage with the Akash Network. Capabilities include automated application deployment, lease lifecycle management, and direct invocation of various Akash primitives via strongly-typed operational methods compatible with the MCP specification.

Core Capabilities

• Credential & Client Handling: Manages the necessary Akash wallet authentication sequences and establishes the required network client connections.
• Certificate Authority Operations: Provides mechanisms for Akash certificate lifecycle management.
• Akash-Specific Toolset: A comprehensive suite of utilities for:
• Retrieving the originating account address.
• Initiating, inspecting, modifying, and retiring deployments.
• Executing operations against Stack Definition Language (SDL) specifications.
• Querying and managing financial bids.
• Provisioning and managing service leases.
• Submitting deployment manifests to providers.

System Requirements

• Runtime Environment: Node.js (version 18 or superior)
• Authentication Asset: An active Akash wallet configured with its recovery mnemonic for network transactions.
• Conceptual Foundation: Familiarity with the operational concepts of the Akash Network is assumed.

Deployment Procedure

1. Obtain the source code repository:

bash git clone https://github.com/akash-network/mcp.git cd mcp

1. Install necessary project dependencies:

bash npm install

1. Compile the source code:

bash npm run build

Integration with AI Environments (e.g., Claude Desktop, Cursor)

Integrate this service by augmenting your configuration file (e.g., claude_desktop_config.json or .cursor/mcp.json). Further instructional details are available at https://modelcontextprotocol.io/quickstart/user.

Crucially, substitute <path to dist/index.js> with the actual compiled file location.

{ "mcpServers": { "Akash-Decentralized-Compute": { "command": "node", "args": [""], "env": { "AKASH_MNEMONIC": "", "AKASH_RPC_URL": "https://rpc.akashnet.net:443" // Optional setting; defaults to this endpoint } } } }

Operational Modes

Engineering/Debugging Mode

To initiate the server while enabling the MCP inspector utility for development purposes:

bash npm run dev

For continuous compilation and reloading during active coding:

bash npm run dev:watch

Agent Interaction Protocol

The server exposes a standardized MCP endpoint. By default, it leverages the standard input/output (stdio) communication channel, ensuring broad compatibility with diverse MCP-enabled AI agents.

Exposed Agent Utilities

The following discrete functions are available for AI agents to invoke against the Akash ledger:

• GetAccountAddrTool: Retrieves the canonical Akash account identifier.
• GetBalancesTool: Fetches the current holdings (AKT in uakt denomination and others) associated with a specified account.
• GetBidsTool: Queries active bids pertaining to specific deployment requests.
• CreateDeploymentTool: Submits a new application blueprint for provisioning on the network.
• GetDeploymentTool: Fetches granular status, group configuration, and escrow details for an active deployment.
• CloseDeploymentTool: Executes the termination sequence for an existing deployment.
• AddFundsTool: Transfers supplementary AKT (uakt) into a deployment's dedicated escrow mechanism.
• GetSDLsTool: Provides an index of exemplary SDL configurations sourced from the awesome-akash repository.
• GetSDLTool: Fetches a singular SDL definition based on its designated identifier.
• SendManifestTool: Transmits the final deployment manifest to the selected provider entity.
• CreateLeaseTool: Finalizes the commitment by establishing a lease with a provider following a successful bid acceptance.
• GetServicesTool: Queries the current operational status of provisioned services.
• UpdateDeploymentTool: Initiates a modification request for an extant deployment configuration.

Code Quality Assurance

Syntax Verification and Styling

bash

Execute linter checks

npm run lint

Automatically correct stylistic issues

npm run lint:fix

Apply standard code formatting rules

npm run format

Licensing Information

See the foundational document located at LICENSE

Attributions

Gratitude extended to the following projects and communities:

• Akash Network
• Model Context Protocol SDK
• awesome-akash (Integrated as a dependency)

WIKIPEDIA: Cloud computing is "a paradigm for enabling network access to a scalable and elastic pool of shareable physical or virtual resources with self-service provisioning and administration on-demand," according to ISO. It is commonly referred to as "the cloud".

== Characteristics == In 2011, the National Institute of Standards and Technology (NIST) identified five "essential characteristics" for cloud systems. Below are the exact definitions according to NIST:

On-demand self-service: "A consumer can unilaterally provision computing capabilities, such as server time and network storage, as needed automatically without requiring human interaction with each service provider." Broad network access: "Capabilities are available over the network and accessed through standard mechanisms that promote use by heterogeneous thin or thick client platforms (e.g., mobile phones, tablets, laptops, and workstations)." Resource pooling: " The provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, with different physical and virtual resources dynamically assigned and reassigned according to consumer demand." Rapid elasticity: "Capabilities can be elastically provisioned and released, in some cases automatically, to scale rapidly outward and inward commensurate with demand. To the consumer, the capabilities available for provisioning often appear unlimited and can be appropriated in any quantity at any time." Measured service: "Cloud systems automatically control and optimize resource use by leveraging a metering capability at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency for both the provider and consumer of the utilized service. By 2023, the International Organization for Standardization (ISO) had expanded and refined the list.

== History ==

The history of cloud computing extends to the 1960s, with the initial concepts of time-sharing becoming popularized via remote job entry (RJE). The "data center" model, where users submitted jobs to operators to run on mainframes, was predominantly used during this era. This was a time of exploration and experimentation with ways to make large-scale computing power available to more users through time-sharing, optimizing the infrastructure, platform, and applications, and increasing efficiency for end users. The "cloud" metaphor for virtualized services dates to 1994, when it was used by General Magic for the universe of "places" that mobile agents in the Telescript environment could "go". The metaphor is credited to David Hoffman, a General Magic communications specialist, based on its long-standing use in networking and telecom. The expression cloud computing became more widely known in 1996 when Compaq Computer Corporation drew up a business plan for future computing and the Internet. The company's ambition was to superch