# MCP Supergraph

The **Tairon MCP Supergraph** is the decentralized data layer that unifies servers, datasets, and tools into one coherent system.

It serves as the oracle layer for AI, robotics, IoT, and RWAs, making every onchain data source accessible to intelligent systems in a secure, verifiable, and composable way. Instead of a fragmented landscape of APIs, the Supergraph provides a single entry point: one graph, one schema, one layer. Every connected server is resolved 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, Robotics, IoT and RWA, the MCP Supergraph delivers a unified, verifiable, and interoperable data fabric, bringing every on-chain dataset into the reach of intelligence.

***

### Supergraph Structure <a href="#supergraph-structure" id="supergraph-structure"></a>

Tairon organizes MCP servers into categories for easy discovery:

**Core Categories**

* Chain-RPC
* Trading MCP Servers
* DeFi
* Market Data
* Social
* Developer Tools

***

### Server Features <a href="#server-features" id="server-features"></a>

**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** <a href="#transport-layer-support" id="transport-layer-support"></a>

**HTTP/REST** - Standard RESTful APIs

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

***

#### **WebSocket** - Real-time data streams <a href="#websocket-real-time-data-streams" id="websocket-real-time-data-streams"></a>

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

***

#### **On-Chain** - Smart contract interactions <a href="#on-chain-smart-contract-interactions" id="on-chain-smart-contract-interactions"></a>

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

***

### **Security Assessment** <a href="#security-assessment" id="security-assessment"></a>

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 <a href="#testing-with-live-inspector" id="testing-with-live-inspector"></a>

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:** <a href="#using-the-inspector" id="using-the-inspector"></a>

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

```javascript
// 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 <a href="#access-methods" id="access-methods"></a>

**Direct API Integration**

Connect directly to MCP servers using their native APIs:

```javascript
// 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** <a href="#zalen-sdk-integration" id="zalen-sdk-integration"></a>

Use the Tairon SDK for enhanced features:

```javascript
// 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** <a href="#mcp-client-integration" id="mcp-client-integration"></a>

Use standard MCP clients for protocol-native integration:

```javascript
// 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' });
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tairon.ai/tairon/mcp-supergraph.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.