Creating an Easy MCP Client to Connect with Hive MCP Server

Skip the complexity of direct API calls. Build your own MCP client in minutes, create reusable data functions, and integrate Hive Intelligence's 60+ blockchain networks into any application or trading strategy.

Why Build Your Own MCP Client?

Hive Intelligence MCP Server is available as a remote HTTP service at https://hiveintelligence.xyz/mcp. No local installation needed—just connect via HTTP and access 60+ blockchains instantly. Build your client once, integrate everywhere.

Quick Start: JavaScript Client in 5 Minutes

Install Dependencies

npm install @modelcontextprotocol/sdk axios

Basic Client Setup

// hive-mcp-client.js
const { Client } = require('@modelcontextprotocol/sdk/http');
const axios = require('axios');

class HiveMCPClient {
  constructor() {
    this.endpoint = 'https://hiveintelligence.xyz/mcp';
    this.client = null;
  }

  async connect() {
    // Hive MCP Server uses HTTP transport (remote server)
    const { HttpClient } = await import('@modelcontextprotocol/sdk/http');

    this.client = new HttpClient({
      baseUrl: this.endpoint,
      headers: {
        'Content-Type': 'application/json'
      }
    });

    console.log('Connected to Hive MCP Server via HTTP');
  }

  async getTokenPrice(symbol) {
    return await this.client.request('tools/call', {
      name: 'get_token_price',
      arguments: { symbol }
    });
  }

  async getWalletBalance(address, chain = 'ethereum') {
    return await this.client.request('tools/call', {
      name: 'get_wallet_balance',
      arguments: { address, chain }
    });
  }
}

module.exports = HiveMCPClient;
      

Python Client Implementation

Python developers can create equally powerful clients using HTTP transport:

# hive_mcp_client.py
import httpx
import asyncio
from typing import Dict, Any

class HiveMCPClient:
    def __init__(self):
        self.base_url = "https://hiveintelligence.xyz/mcp"
        self.client = None

    async def connect(self):
        """Connect to Hive MCP Server via HTTP"""
        self.client = httpx.AsyncClient(
            base_url=self.base_url,
            headers={"Content-Type": "application/json"}
        )
        print("Connected to Hive MCP Server via HTTP")

    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]):
        """Call a tool on the MCP server"""
        response = await self.client.post(
            "/tools/call",
            json={"name": tool_name, "arguments": arguments}
        )
        return response.json()

    async def get_defi_yields(self, protocol="all", min_apy=0):
        """Fetch DeFi yields across protocols"""
        return await self.call_tool(
            "get_defi_yields",
            {"protocol": protocol, "min_apy": min_apy}
        )

    async def get_nft_floor_prices(self, collection):
        """Get NFT collection floor prices"""
        return await self.call_tool(
            "get_nft_floor",
            {"collection": collection}
        )

    async def close(self):
        """Close the HTTP client connection"""
        if self.client:
            await self.client.aclose()
      

Building Reusable Data Functions

Market Analysis Functions

// market-analysis.js
class MarketAnalysis {
  constructor(mcpClient) {
    this.client = mcpClient;
  }

  async getMarketOverview(tokens) {
    const data = await Promise.all(
      tokens.map(async (token) => ({
        symbol: token,
        price: await this.client.request('tools/call', {
          name: 'get_token_price',
          arguments: { symbol: token }
        }),
        volume24h: await this.client.request('tools/call', {
          name: 'get_24h_volume',
          arguments: { symbol: token }
        }),
        liquidity: await this.client.request('tools/call', {
          name: 'get_liquidity',
          arguments: { symbol: token }
        })
      }))
    );
    return data;
  }

  async findArbitrageOpportunities(token, minSpread = 0.5) {
    const exchanges = ['uniswap', 'sushiswap', 'curve'];
    const prices = await Promise.all(
      exchanges.map(dex =>
        this.client.request('tools/call', {
          name: 'get_dex_price',
          arguments: { token, dex }
        })
      )
    );

    // Calculate spreads and return opportunities
    return this.calculateArbitrage(prices, minSpread);
  }
}
      

Portfolio Tracking Functions

// portfolio-tracker.js
class PortfolioTracker {
  constructor(mcpClient) {
    this.client = mcpClient;
  }

  async getMultiChainBalance(address) {
    const chains = ['ethereum', 'polygon', 'arbitrum', 'optimism'];
    const balances = {};

    for (const chain of chains) {
      balances[chain] = await this.client.request('tools/call', {
        name: 'get_wallet_balance',
        arguments: { address, chain }
      });
    }

    return this.aggregateBalances(balances);
  }

  async trackYieldFarming(address) {
    const positions = await this.client.request('tools/call', {
      name: 'get_defi_positions',
      arguments: { address }
    });

    return positions.map(pos => ({
      protocol: pos.protocol,
      value: pos.value,
      apy: pos.apy,
      rewards: pos.pendingRewards
    }));
  }
}
      

Exporting for Trading Strategies

Package your functions into a reusable module:

// hive-trading-toolkit.js
const HiveMCPClient = require('./hive-mcp-client');
const MarketAnalysis = require('./market-analysis');
const PortfolioTracker = require('./portfolio-tracker');

class HiveTradingToolkit {
  constructor() {
    this.client = new HiveMCPClient();
    this.market = new MarketAnalysis(this.client);
    this.portfolio = new PortfolioTracker(this.client);
  }

  async initialize() {
    await this.client.connect();
    return this;
  }

  // High-level strategy functions
  async executeGridTrading(config) {
    const { token, gridLevels, amount } = config;
    const price = await this.client.getTokenPrice(token);

    // Set up grid orders
    const orders = this.calculateGridLevels(price, gridLevels);
    return await this.placeGridOrders(orders, amount);
  }

  async monitorWhaleActivity(tokens) {
    return await this.client.callTool('track_whale_transfers', {
      tokens,
      minValue: 100000
    });
  }
}

// Export for use in any Node.js application
module.exports = HiveTradingToolkit;
      

Real-World Usage Examples

Automated DeFi Yield Optimizer

const HiveTradingToolkit = require('./hive-trading-toolkit');

async function optimizeYield() {
  const toolkit = await new HiveTradingToolkit().initialize();

  // Find best yields via HTTP request
  const yields = await toolkit.client.request('tools/call', {
    name: 'get_defi_yields',
    arguments: {
      minAPY: 10,
      chains: ['ethereum', 'polygon']
    }
  });

  // Rebalance to highest yield
  const best = yields.result[0];
  console.log(`Moving funds to ${best.protocol} at ${best.apy}% APY`);
}

// Run every hour
setInterval(optimizeYield, 3600000);
      

Cross-Chain Arbitrage Bot

async def arbitrage_scanner():
    client = HiveMCPClient()
    await client.connect()

    while True:
        # Check USDC prices across chains
        prices = {}
        for chain in ['ethereum', 'polygon', 'arbitrum']:
            price = await client.session.call_tool(
                'get_token_price',
                {'token': 'USDC', 'chain': chain}
            )
            prices[chain] = price

        # Execute if spread > 0.1%
        if max(prices.values()) - min(prices.values()) > 0.001:
            await execute_arbitrage(prices)

        await asyncio.sleep(10)
      

Best Practices

Connection Management: Implement reconnection logic for production systems.

Error Handling: Wrap all MCP calls in try-catch blocks with fallback strategies.

Rate Limiting: Respect server limits—batch requests when possible.

Caching: Store frequently accessed data locally with TTL expiration.

Advanced Features

Batch Requests: Send multiple tool calls in a single HTTP request to optimize performance.

Response Caching: Implement client-side caching to reduce API calls for frequently accessed data.

Retry Logic: Add exponential backoff for failed requests to handle temporary network issues.

Start Building Today

Your MCP client is the gateway to Hive Intelligence's blockchain data universe. In minutes, you've built a foundation for trading bots, portfolio trackers, and DeFi strategies that work across 60+ chains.

Start using Hive Intelligence MCP →