mesh-heurist-protocol-gateway
Facilitates connections to diverse blockchain and Web3 utilities through the Heurist Mesh Application Programming Interface, granting access to cryptocurrency intelligence, smart contract auditing, and direct chain operations.
Author

heurist-network
Quick Info
Actions
Tags
Mesh Orchestrator Model Context Protocol Server
An MCP node functioning as a server interface to the Heurist Mesh Infrastructure, furnishing conversational AI agents like Claude with programmatic entry points to specialized web3 operational toolsets.
The Heurist Mesh represents a decentralized collective of expertly designed artificial intelligence operatives and software modules, each focusing on specific distributed ledger technology (DLT) domains, encompassing ledger data forensics, security vulnerability assessment for digital contracts, token economic metrics derivation, and transaction execution capabilities. We are continuously expanding the utility landscape of the Heurist Mesh ecosystem by onboarding supplementary instruments.
Core Capabilities
- Establishes persistent linkage with the Heurist Mesh service layer API
- Integrates instrumental functions for digital asset valuation and decentralized finance (DeFi) tasks
- Supports both Streaming Server-Sent Events (SSE) and standard input/output (stdio) communication protocols
- Fully interoperable with Claude within Cursor, the standalone Claude Desktop client, and other compliant MCP frameworks
- A singular authentication token unlocks broad access across numerous backend services (e.g., market intelligence from CoinGecko, security analysis from GoPlus)
🔥 Latest Enhancement: On-Demand Server Configuration and Agent Composition
Leverage the Heurist Mesh MCP Configuration Portal to spin up custom SSE-based MCP server instances. Define your required agent swarm composition dynamically to meet specific task prerequisites!
Publicly Available SSE Access Point
We maintain a globally accessible SSE gateway at https://sequencer-v2.heurist.xyz/mcp/sse. This endpoint aggregates capabilities from the following routinely utilized agents: CoingeckoTokenInfoAgent, ElfaTwitterIntelligenceAgent, ExaSearchAgent, DexScreenerTokenInfoAgent, ZerionWalletAnalysisAgent. Note that this is a shared resource, and performance variability may occur.
Clients utilizing Cursor can connect directly to SSE URIs. Users of Claude Desktop are advised to implement the intermediary component, mcp-proxy, to bridge to the SSE endpoint.
System Requirements
- Execution environment requires Python version 3.10 or newer
- Installation via the UV package resolver is strongly encouraged
- Alternatively, deployment via Docker containers is supported
- Acquisition of a Heurist Access Credential is mandatory (Details on API Credits) or you may secure complimentary initial credits using the invocation code "claude"
Deployment Instructions
Utilizing UV (Recommended Path)
bash
Obtain the source code repository
git clone https://github.com/heurist-network/heurist-mesh-mcp-server.git cd heurist-mesh-mcp-server
Perform an editable installation of the dependency
uv pip install -e .
Deploying via Docker
bash
Obtain the source code repository
git clone https://github.com/heurist-network/heurist-mesh-mcp-server.git cd heurist-mesh-mcp-server
Construct the container image named mesh-tool-server
docker build -t mesh-tool-server .
Operational Guide
Method 1: Execution via stdio Channel (Intended for Claude Desktop)
Using UV Environment
To integrate this setup with Claude Desktop, introduce the following configuration block into your claude_desktop_config.json:
{ "mcpServers": { "heurist-mesh-agent": { "command": "uv", "args": [ "--directory", "/path/to/heurist-mesh-mcp-server/mesh_mcp_server", // Substitute with your actual directory location "run", "mesh-tool-server" ], "env": { "HEURIST_API_KEY": "your-api-key-here" // Substitute with your secret credential } } } }
Using Docker Containerization
Alternatively, Docker integration for Claude Desktop involves this entry in claude_desktop_config.json:
{ "mcpServers": { "mesh-agent": { "command": "docker", "args": [ "run", "--rm", "-i", "-e", "TRANSPORT=stdio", "-e", "HEURIST_API_KEY=your-api-key-here", // Substitute your key here "mesh-tool-server" ] } } }
Ensure you substitute /path/to/heurist-mesh-mcp-server with the absolute repository location and your-api-key-here with your valid Heurist access token.
Method 2: Operation via SSE Endpoint (Optimal for Cursor)
Configuring Environmental Variables with a .env File
bash cp .env.example .env HEURIST_API_KEY=your-api-key-here
Utilizing UV:
bash uv run mesh-tool-server --transport sse --port 8000
Utilizing Docker:
bash docker run -p 8000:8000 -e PORT=8000 mesh-tool-server
Subsequently, within the Cursor application, register the MCP Server endpoint as: http://0.0.0.0:8000/sse
Catalog of Accessible Functions
Consult https://mesh.heurist.ai/metadata.json or https://mcp.heurist.ai/ for a comprehensive registry of all exposed operational modules.
Highlighted Toolkit Modules
| Function Identifier | Utility Description | Associated Agent Module | Input Arguments | Essential Arguments |
|---|---|---|---|---|
| get_coingecko_id | Locates a specified asset by its common designation to resolve its CoinGecko identifier | CoinGeckoTokenInfoAgent | token_name (text): The descriptive designation for lookup | token_name |
| get_token_info | Retrieves comprehensive asset metrics and market data utilizing the CoinGecko ID (Note: Address/Symbol/Name input is invalid) | CoinGeckoTokenInfoAgent | coingecko_id (text): The unique CoinGecko identifier for the asset | coingecko_id |
| get_trending_coins | Fetches the compilation of currently popular digital currencies listed on CoinGecko | CoinGeckoTokenInfoAgent | - | None |
| get_specific_pair_info | Fetches transactional pairing details based on the network identifier and contract address on DexScreener | DexScreenerTokenInfoAgent | chain (text): Network identifier (e.g., solana, ethereum, base) pair_address (text): The contract address defining the trading pool |
chain, pair_address |
| get_token_pairs | Queries for all active trading pools associated with a specific asset address on a given network via DexScreener | DexScreenerTokenInfoAgent | chain (text): Network identifier (e.g., solana, bsc, ethereum, base) token_address (text): The asset's contract address to source associated pools |
chain, token_address |
| get_token_profiles | Retrieves fundamental data summaries for recently indexed assets from DexScreener | DexScreenerTokenInfoAgent | - | None |
| search_pairs | Executes a generalized query across DexScreener for trading pools matching a text string (name, ticker, or address) | DexScreenerTokenInfoAgent | search_term (text): Query string matching token name, symbol, or address | search_term |
| get_trending_tokens | Reports on assets currently exhibiting high engagement on the Twitter platform | ElfaTwitterIntelligenceAgent | time_window (text): The temporal scope for trend assessment | None |
| search_account | Performs a forensic review of a designated social media profile, including mention frequency and statistics | ElfaTwitterIntelligenceAgent | username (text): The target profile handle (excluding the leading '@') days_ago (number): Horizon for historical mention analysis limit (number): Maximum count of mention records to retrieve |
username |
| search_mentions | Scans the social media stream for discussions related to specific assets or subjects | ElfaTwitterIntelligenceAgent | keywords (list): Collection of search terms to match against posts days_ago (number): Lookback duration for tweet retrieval limit (number): Maximum response size (minimum acceptable value: 20) |
keywords |
| answer | Provides a direct, synthesized response to an inquiry utilizing Exa's proprietary question-answering engine | ExaSearchAgent | question (text): The specific query requiring a conclusive answer | question |
| search | Executes a web index lookup against a specified query string | ExaSearchAgent | search_term (text): The primary subject for the web crawl limit (number): Maximum number of resulting documents to return (defaults to 10) |
search_term |
| search_and_answer | Concurrently performs a broad web surface search and synthesizes an answer from the findings | ExaSearchAgent | topic (text): The subject matter underpinning both the search and synthesis process | topic |
| execute_search | Triggers a live web search operation, processing the content of the retrieved documents | FirecrawlSearchAgent | search_term (text): The query string to initiate the retrieval process | search_term |
| generate_queries | Formulates a set of derivative research questions based on an initial topic to facilitate deeper investigation | FirecrawlSearchAgent | topic (text): The initial subject under study num_queries (number): The desired quantity of supplementary research questions |
topic |
| fetch_security_details | Retrieves audited security metrics for a specified distributed ledger asset contract | GoplusAnalysisAgent | contract_address (text): The unique identifier of the token contract chain_id (['integer', 'text']): The DLT network identifier or 'solana'. Supported networks include: Ethereum (1), Optimism (10), Cronos (25), BSC (56), Gnosis (100), HECO (128), Polygon (137), Fantom (250), KCC (321), zkSync Era (324), ETHW (10001), FON (201022), Arbitrum (42161), Avalanche (43114), Linea Mainnet (59144), Base (8453), Tron (tron), Scroll (534352), opBNB (204), Mantle (5000), ZKFair (42766), Blast (81457), Manta Pacific (169), Berachain Artio Testnet (80085), Merlin (4200), Bitlayer Mainnet (200901), zkLink Nova (810180), X Layer Mainnet (196), Solana (solana) |
contract_address |
Modifying Inclusions for Operational Agents
The server initializes with a standard complement of integrated agents. To adjust the active agent manifest:
1. Access and open the server.py source file.
2. Locate the configuration block labeled the Config class.
3. Modify the DEFAULT_AGENTS collection to include or exclude agents listed in the Heurist Master Metadata Index
python
DEFAULT_AGENTS = [
"CoinGeckoTokenInfoAgent",
"DexScreenerTokenInfoAgent",
"ElfaTwitterIntelligenceAgent",
"ExaSearchAgent",
"FirecrawlSearchAgent",
"GoplusAnalysisAgent",
# Introduce new agent identifiers below
"NewAgent"
]
Governance
This MCP server component is distributed under the permissive MIT License. This grants unrestricted rights to utilize, amend, and disseminate the software, contingent upon adherence to the stipulated terms and conditions of the MIT License.
WIKIPEDIA: XMLHttpRequest (XHR) is an Application Programming Interface presented as a JavaScript construct that facilitates the dispatching of HTTP data requests from a web client environment to a remote server. The methods embedded within XHR enable client-side applications to initiate server communications subsequent to page rendering completion, and subsequently receive solicited data. XMLHttpRequest is a foundational element of Asynchronous JavaScript and XML (Ajax) programming methodologies. Preceding Ajax adoption, the primary mechanisms for server synchronization involved navigation via standard hyperlinks and form submissions, actions that frequently necessitated a full page refresh.
== Genesis of Concept ==
The underlying concept driving XMLHttpRequest was first conceptualized in the year 2000 by the software architects responsible for Microsoft Outlook development. This concept was subsequently operationalized within the Internet Explorer 5 browser release (1999). However, the initial programmatic syntax did not employ the XMLHttpRequest textual identifier; instead, developers relied upon the invocation of ActiveXObject("Msxml2.XMLHTTP") or ActiveXObject("Microsoft.XMLHTTP"). By the release of Internet Explorer 7 (2006), universal support for the standardized XMLHttpRequest identifier had been established across all major browser platforms, including Mozilla's Gecko rendering engine (2002), Safari version 1.2 (2004), and Opera version 8.0 (2005).
=== Formalization === The World Wide Web Consortium (W3C) issued the initial Working Draft specification detailing the XMLHttpRequest object on April 5, 2006. A subsequent Working Draft, designated Level 2, was published by the W3C on February 25, 2008. This Level 2 revision augmented the interface with functionalities for tracking request progress events, enabling secure cross-origin data transfers, and managing raw byte stream data. Towards the close of 2011, the features defined in the Level 2 specification were formally integrated back into the primary specification document. At the conclusion of 2012, responsibility for maintenance shifted to the WHATWG group, which now maintains the authoritative document using the Web Interface Definition Language (Web IDL).
== Operational Sequence == Generally, the process of dispatching a request using XMLHttpRequest involves several distinct programming phases.
- Instantiation: An instance of the XMLHttpRequest object must be generated by invoking its constructor method:
- Configuration: The "open" method is subsequently invoked to define the request's HTTP verb, specify the target Uniform Resource Identifier (URI), and select the execution mode (synchronous or asynchronous):
- Listener Setup (Asynchronous Only): For asynchronous operations, an event handler must be established to monitor state transitions and receive notifications upon completion:
- Transmission: The request is formally initiated by calling the "send" method, optionally carrying payload data:
- Response Handling: The event listener must process the state changes. Upon successful receipt of server data, the response payload is typically accessible via the "responseText" attribute. When the object signals the termination of the response processing cycle, the ready state advances to 4, signifying the "done" status. Beyond these fundamental steps, XMLHttpRequest offers extensive configuration options governing request transmission and response processing. Custom HTTP header fields can be injected to dictate server behavior. Data can be uploaded by passing it directly into the "send" invocation. Furthermore, the incoming payload can be parsed automatically from JSON structure into native JavaScript objects, or processed incrementally as data arrives, bypassing full buffer wait times. The operation can also be terminated prior to completion or configured with a timeout threshold.
