MCP Supergraph

The Tairon MCP Supergraph is the decentralized, on-chain registry that maps the entire ecosystem of servers, datasets, and tools into one unified layer. It acts as the oracle layer for AI, making every on-chain data source accessible to intelligent systems in a secure, verifiable, and composable way.

Where traditional APIs fragment the Web3 landscape, the Supergraph provides a single entry point: one graph, one schema, one registry, resolving every registered server into an oracle feed that can be queried and tested in real time.

---

From Fragmented APIs to Intelligence Oracles

The MCP Supergraph closes a fundamental gap in Web3: connectivity for autonomous systems.

• For developers → No more manual integrations. The oracle layer standardizes access to every protocol endpoint.

• For AI systems → A machine-readable map of live, verifiable data sources and callable functionality across the decentralized stack.

• For protocols → A direct way to expose their data and tools as oracles, instantly discoverable and consumable by the next generation of applications.

By standardizing servers as oracles for AI, the MCP Supergraph delivers a unified, verifiable, and interoperable data fabric, bringing every on-chain dataset into the reach of intelligence.

---

Supergraph Structure

Tairon organizes MCP servers into categories for easy discovery:

Core Categories

• Chain-RPC

• Trading MCP Servers

• DeFi

• Market Data

• Social

• Developer Tools

---

Server Features

Browse by Capability

Each server is tagged with its capabilities:

Transport Layers:
  - HTTP/REST
  - WebSocket
  - GraphQL
  - gRPC

Security Features:
  - API Key Authentication
  - OAuth 2.0
  - JWT Tokens
  - Rate Limiting

Data Formats:
  - JSON
  - Protocol Buffers
  - MessagePack
  - XML

---

Transport Layer Support

HTTP/REST - Standard RESTful APIs

const httpServer = await client.getServer('rest-api-v1');
const data = await httpServer.get('/api/data');

---

WebSocket - Real-time data streams

const wsServer = await client.getServer('websocket-feed');
wsServer.subscribe('price-updates', (data) => {
  console.log('Price update:', data);
});

---

On-Chain - Smart contract interactions

const chainServer = await client.getServer('ethereum-oracle');
const price = await chainServer.call('latestPrice', { pair: 'ETH/USD' });

---

Security Assessment

Every server displays security information:

• Security Audit Status: Passed/Pending/Failed

• Authentication Methods: Supported auth types

• Uptime Metrics: 99.9% availability

• Performance: Response times and throughput

---

Testing with Live Inspector

The Live Inspector lets you test any server directly in your browser:

Features:

• Real-time Testing: Execute functions and see results instantly

• Schema Validation: Automatic parameter validation

• Response Analysis: Detailed response inspection

• Error Handling: Clear error messages and debugging info

• Code Generation: Auto-generate integration code

---

Using the Inspector:

1. Select a Server: Click "Test With Inspector" on any server page

2. Choose Function: Select from available server functions

3. Set Parameters: Fill in required parameters with validation

4. Execute: Run the function and see real-time results

5. Generate Code: Copy integration code for your language

// Example generated code
const taironClient = new TaironClient();
const server = await TaironClient.getServer('price-oracle-v1');

try {
  const result = await server.call('getPrice', {
    symbol: 'ETH/USD',
    source: 'binance'
  });
  console.log('Price:', result.price);
} catch (error) {
  console.error('Error:', error.message);
}

---

Access Methods

Direct API Integration

Connect directly to MCP servers using their native APIs:

// Direct HTTP integration
const response = await fetch('https://api.example-server.com/execute', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer your-api-key'
  },
  body: JSON.stringify({
    function: 'getPrice',
    parameters: { symbol: 'ETH/USD' }
  })
});

---

Tairon SDK Integration

Use the Tairon SDK for enhanced features:

// SDK integration with automatic discovery
const client = new TaironClient();
const servers = await client.discover({
  category: 'defi',
  tags: ['price-oracle'],
  minUptime: 99.5
});

const bestServer = servers[0];
const result = await bestServer.call('getPrice', { symbol: 'ETH/USD' });

---

MCP Client Integration

Use standard MCP clients for protocol-native integration:

// Standard MCP client
import { MCPClient } from '@mcp/client';

const client = new MCPClient('https://api.example-server.com');
const capabilities = await client.getCapabilities();
const result = await client.execute('getPrice', { symbol: 'ETH/USD' });