# Tairon
**Tairon connects blockchain data to AI, robotics, IoT, and RWAs through a purpose-built oracle data layer.**
Our mission is to make every blockchain protocol and application accessible to developers and intelligent systems. Today, onchain data is scattered across thousands of chains and applications, with no common standard. This fragmentation makes it difficult to build with and prevents AI, automation, and real-world systems from tapping into the full potential of Web3.
Tairon delivers one source of truth for onchain data. Through the MCP Supergraph, signals from protocols and datasets are unified into a verifiable data layer. This layer transforms raw blockchain activity into live, trusted feeds that can be integrated into applications, AI agents, robotics, IoT networks, and financial systems.
This documentation is your guide to the Tairon oracle data layer. It explains how the Supergraph works, how oracle feeds are structured, and how endpoints can be integrated into your stack. It also provides details on publishing data sources, running tests, and contributing modules to expand the ecosystem.
***
### Table of Contents
1. [Introduction](/tairon/introduction)
2. [Getting Started](/tairon/getting-started)
3. [MCP Supergraph](/tairon/mcp-supergraph)
4. [MCP Inspector](/tairon/mcp-inspector)
5. [MCP Server Development](/tairon/mcp-server-development)
6. [Server Submission](/tairon/server-submission)
7. [Testing and Validation](/tairon/testing-and-validation)
8. [Troubleshooting](/tairon/troubleshooting)
9. [Team](/tairon/team)
10. [Tokenomics](/tairon/tokenomics)
11. [Token Utility](/tairon/token-utility)
12. [FAQ](/tairon/faq)
13. [Contact Tairon](/tairon/contact-tairon)
# Introduction
### What is Tairon?
Tairon is the oracle data layer for AI, robotics, IoT, and RWAs. It unifies blockchain data into a single graph that can be accessed, tested, and integrated through one API.
Developers gain a consistent way to connect with protocols and applications without building custom integrations. Signals from across chains are transformed into live, verifiable feeds that can power AI agents, robotic systems, connected devices, and tokenized assets.
Tairon opens the door to a $125B+ market where intelligent systems depend on reliable, real-time inputs. It bridges fragmented blockchain activity with the industries and applications that need it most.
### Pillars of the Supergraph
* **Discovery at scale**\
Thousands of MCP servers and data sources available in one place.
* **Real-time validation**\
Endpoints can be inspected and tested instantly for accuracy and trust.
* **Security and trust**\
Signals are protected with audits, provenance tracking, and compliance checks.
* **Operational visibility**\
Developers and enterprises monitor performance, reliability, and uptime for every feed.
* **Web3 native design**\
Built for onchain environments and decentralized applications from the ground up.
***
### The Model Context Protocol (MCP)
[MCP](https://modelcontextprotocol.io/) is a standardized protocol that enables applications to interact with external services through a minimal HTTP API. It defines how servers expose structured, callable functionality that can be discovered and consumed by client applications.
**MCP Core Concepts:**
* **Endpoints**: Standardized HTTP routes (`/health`, `/capabilities`, `/execute`)
* **Functions**: Named operations with defined input/output schemas
* **Schemas**: JSON schemas for type-safe interactions
* **Metadata**: Server information and capability descriptions
***
### The Value of the Oracle Layer
Web3 has grown to thousands of protocols and applications, but there is still no standard way for AI, robotics, IoT, and RWAs to access blockchain data. APIs are fragmented, endpoints are inconsistent, and integrations often break. Intelligent systems are left blind to the activity happening across crypto.
Tairon provides the oracle data layer that solves this problem. Signals from chains and protocols are unified into a single, verifiable layer that can be discovered, tested, and integrated with ease. Developers no longer need to build custom bridges for every application, they can connect once and gain access to the entire Supergraph.
#### **With Tairon, developers gain:**
* **Verified servers**: every integration is reviewed for compliance and security
* **Real-time testing**: endpoints can be validated instantly before going live
* **Flexible transport:** works across HTTP, WebSocket, and onchain protocols
* **Faster building**: SDKs, documentation, and working examples cut integration time
* **Open participation**: a transparent, community-driven network that grows stronger with each contribution
# Getting Started
### Quick Start
Get up and running with Tairon in minutes:
***
#### **1. Browse the Supergraph**
Visit [tairon.ai ](http://tairon.ai/)to explore available MCP servers:
* **Browse by Category**: DeFi, Gaming, Data Processing, AI/ML
* **Filter by Transport**: HTTP, WebSocket, gRPC
* **Security Filters**: Audited servers, open source only
* **Performance Filters**: Uptime, response time, throughput
***
#### **2. Test Servers Live**
Use the built-in **Live Inspector** to test any server:
```bash
# No installation required - test directly in browser
# Visit: https://tairon.ai/servers/{server-id}/test
# Or use our CLI tool
npm install -g @tairon/cli
tairon test server-id --function getPrice --params '{"symbol":"ETH/USD"}'
```
***
#### **3. Integrate with Your App**
```javascript
// Install the SDK
npm install @tairon/sdk
// Quick integration
import { TaironClient } from '@tairon/sdk';
const client = new taironClient();
const server = await client.getServer('price-oracle-v1');
const result = await server.call('getPrice', { symbol: 'ETH/USD' });
```
***
#### Installation
**SDK Installation**
```bash
# NPM
npm install @tairon/sdk
# Yarn
yarn add @tairon/sdk
# PNPM
pnpm add @tairon/sdk
# Bun
bun add @tairon/sdk
```
***
#### **CLI Installation**
```bash
# Global installation
npm install -g @tairon/cli
# Verify installation
tairon --version
```
***
#### Authentication
Most operations are **public and free**. Premium features require an API key:
```bash
# Set up authentication
tairon auth login
# Or use environment variable
export TAIRON_API_KEY="your-api-key"
```
# 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
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
```bash
const httpServer = await client.getServer('rest-api-v1');
const data = await httpServer.get('/api/data');
```
***
#### **WebSocket** - Real-time data streams
```bash
const wsServer = await client.getServer('websocket-feed');
wsServer.subscribe('price-updates', (data) => {
console.log('Price update:', data);
});
```
***
#### **On-Chain** - Smart contract interactions
```bash
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
```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
**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**
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**
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' });
```
# MCP Inspector
### What is Tairon Inspector?
Tairon Inspector is a web-based tool that lets you interactively test and debug MCP servers. It provides a live interface to send requests, view responses, check server health, and validate that endpoints behave correctly, all without writing code.
It’s designed to help developers quickly verify server functionality, diagnose issues, and understand the expected inputs and outputs for MCP-compliant endpoints.
***
#### **1. Accessing the Inspector**
* Open [tairon.ai](http://tairon.ai/)
* Navigate to any server listing in the directory.
* Click the **Inspect** button on the server card or detail page.
***
#### **2. Using the Inspector**
* The Inspector UI lets you run requests to all exposed MCP endpoints (`/health`, `/capabilities`, `/execute`, etc.).
* Input sample JSON payloads or use predefined test cases.
* View live response data including status codes, headers, response times, and payload content.
| Feature | Description |
| ------------------- | ----------------------------------------------------- |
| **Request Editor** | Edit or create custom request bodies in JSON. |
| **Response Viewer** | See formatted response data with syntax highlighting. |
| **Status Codes** | View HTTP status codes and error messages. |
| **Latency Info** | Measure request duration for performance testing. |
| **Save Tests** | Save frequent test inputs for quick access. |
***
#### **3. Benefits of Using Inspector**
* Quickly validate server compliance with MCP spec.
* Debug input/output mismatches or unexpected errors.
* Compare different server responses side-by-side.
* Use as a reference while coding your integration.
***
#### **4. Troubleshooting with Inspector**
* Use Inspector to reproduce issues reported by your application.
* Check for authentication errors, malformed requests, or server errors.
* Validate that all required endpoints respond as expected.
# MCP Server Development
### Server Requirements
To be listed in Tairon's directory, MCP servers must meet these requirements:
#### **Core Requirements**
**MCP v1.0+ Support**
* Implement all required MCP endpoints
* Follow protocol specifications
* Provide proper error handling
***
**Documented API**
* Complete API documentation
* Function descriptions and examples
* Parameter and return type definitions
***
**Security Audit Preferred**
* Optional but recommended security review
* Vulnerability assessments
* Best practices compliance
***
**Open Source or Verifiable Builds**
* Public source code repository, OR
* Verifiable build artifacts
* Reproducible deployments
***
### MCP Endpoint Reference
**`GET /health` – Health Check**
Basic status check used to confirm that a server is operational.
**Method:** `GET` **URL:** `https://your-server.com/health`
**Response Example:**
```bash
{
"status": "ok",
"uptime": 102934,
"timestamp": "2025-06-30T12:34:56Z"
}
```
* `status`: Should return `ok` if the server is operational
* `uptime`: Time (in seconds) the server has been up
* `timestamp`: ISO 8601 timestamp of the check
***
**`GET /capabilities` – Function Discovery**
Returns a list of callable functions exposed by the MCP server.
**Method:** `GET` **URL:** `https://your-server.com/capabilities`
**Response Example:**
```json5
{
"functions": [
{
"name": "extract_entities",
"description": "Extracts named entities from a string",
"inputs": ["text"],
"outputs": ["entities"]
},
{
"name": "get_exchange_rate",
"description": "Returns current exchange rate between two currencies",
"inputs": ["from", "to"],
"outputs": ["rate"]
}
]
}
```
* `name`: Function identifier to be used with `/execute`
* `description`: Human-readable explanation of function
* `inputs`: List of expected input keys
* `outputs`: List of output keys
***
**`POST /execute` – Function Execution**
Main execution endpoint for calling any available function listed in `/capabilities`.
**Method:** `POST` **URL:** `https://your-server.com/execute` **Headers:**
```
Content-Type: application/json
```
**Request Example:**
```json
{
"function": "get_exchange_rate",
"input": {
"from": "USD",
"to": "EUR"
}
}
```
**Response Example:**
```json
{
"output": {
"rate": 0.9254
}
}
```
* `function`: Must match a name returned by `/capabilities`
* `input`: Object with named parameters expected by the function
* `output`: Object with named result keys as defined by the server
***
### Development Templates
#### **Node.js Template**
```json
const express = require('express');
const app = express();
// Middleware
app.use(express.json());
app.use(require('cors')());
// Server configuration
const SERVER_CONFIG = {
name: 'My MCP Server',
version: '1.0.0',
mcpVersion: '1.0.0',
description: 'Description of your server'
};
// Function registry
const functions = new Map();
// Register a function
function registerFunction(name, handler, schema) {
functions.set(name, { handler, schema });
}
// Health endpoint
app.get('/health', (req, res) => {
res.json({
status: 'healthy',
timestamp: new Date().toISOString(),
version: SERVER_CONFIG.version,
mcpVersion: SERVER_CONFIG.mcpVersion
});
});
// Capabilities endpoint
app.get('/capabilities', (req, res) => {
const functionList = Array.from(functions.entries()).map(([name, func]) => ({
name,
description: func.schema.description,
parameters: func.schema.parameters,
returns: func.schema.returns
}));
res.json({
mcpVersion: SERVER_CONFIG.mcpVersion,
server: {
name: SERVER_CONFIG.name,
version: SERVER_CONFIG.version,
description: SERVER_CONFIG.description
},
functions: functionList
});
});
// Execute endpoint
app.post('/execute', async (req, res) => {
const { function: functionName, parameters, requestId } = req.body;
try {
const func = functions.get(functionName);
if (!func) {
return res.status(400).json({
error: {
code: 'FUNCTION_NOT_FOUND',
message: `Function '${functionName}' not found`
},
requestId
});
}
const startTime = Date.now();
const result = await func.handler(parameters);
const executionTime = Date.now() - startTime;
res.json({
requestId,
result,
executionTime
});
} catch (error) {
res.status(500).json({
error: {
code: 'EXECUTION_ERROR',
message: error.message
},
requestId
});
}
});
// Example function registration
registerFunction('getPrice', async (params) => {
// Your function logic here
return {
price: 2345.67,
timestamp: new Date().toISOString(),
symbol: params.symbol
};
}, {
description: 'Get current price for a trading pair',
parameters: {
type: 'object',
properties: {
symbol: { type: 'string', description: 'Trading pair symbol' }
},
required: ['symbol']
},
returns: {
type: 'object',
properties: {
price: { type: 'number' },
timestamp: { type: 'string' },
symbol: { type: 'string' }
}
}
});
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`MCP Server running on port ${PORT}`);
});
```
#### **Python Template**
```python
from flask import Flask, request, jsonify
from datetime import datetime
import time
app = Flask(__name__)
# Server configuration
SERVER_CONFIG = {
'name': 'My MCP Server',
'version': '1.0.0',
'mcpVersion': '1.0.0',
'description': 'Description of your server'
}
# Function registry
functions = {}
def register_function(name, handler, schema):
functions[name] = {'handler': handler, 'schema': schema}
@app.route('/health', methods=['GET'])
def health():
return jsonify({
'status': 'healthy',
'timestamp': datetime.utcnow().isoformat() + 'Z',
'version': SERVER_CONFIG['version'],
'mcpVersion': SERVER_CONFIG['mcpVersion']
})
@app.route('/capabilities', methods=['GET'])
def capabilities():
function_list = []
for name, func in functions.items():
function_list.append({
'name': name,
'description': func['schema']['description'],
'parameters': func['schema']['parameters'],
'returns': func['schema']['returns']
})
return jsonify({
'mcpVersion': SERVER_CONFIG['mcpVersion'],
'server': {
'name': SERVER_CONFIG['name'],
'version': SERVER_CONFIG['version'],
'description': SERVER_CONFIG['description']
},
'functions': function_list
})
@app.route('/execute', methods=['POST'])
def execute():
data = request.get_json()
function_name = data.get('function')
parameters = data.get('parameters', {})
request_id = data.get('requestId')
try:
if function_name not in functions:
return jsonify({
'error': {
'code': 'FUNCTION_NOT_FOUND',
'message': f"Function '{function_name}' not found"
},
'requestId': request_id
}), 400
start_time = time.time()
result = functions[function_name]['handler'](parameters)
execution_time = int((time.time() - start_time) * 1000)
return jsonify({
'requestId': request_id,
'result': result,
'executionTime': execution_time
})
except Exception as e:
return jsonify({
'error': {
'code': 'EXECUTION_ERROR',
'message': str(e)
},
'requestId': request_id
}), 500
# Example function
def get_price(params):
return {
'price': 2345.67,
'timestamp': datetime.utcnow().isoformat() + 'Z',
'symbol': params.get('symbol')
}
# Register the function
register_function('getPrice', get_price, {
'description': 'Get current price for a trading pair',
'parameters': {
'type': 'object',
'properties': {
'symbol': {'type': 'string', 'description': 'Trading pair symbol'}
},
'required': ['symbol']
},
'returns': {
'type': 'object',
'properties': {
'price': {'type': 'number'},
'timestamp': {'type': 'string'},
'symbol': {'type': 'string'}
}
}
})
if __name__ == '__main__':
app.run(debug=True, port=3000)
```
***
### Testing Your Server
Before submitting to Tairon, test your server locally:
```bash
# Install testing tools
npm install -g @tairon/test-suite
# Test your server
tairon-test http://localhost:3000 --comprehensive
# Example output:
# Health check endpoint
# Capabilities discovery
# Function execution
# Error handling
# Schema validation
# Rate limiting not implemented
# Security scan passed
```
# Server Submission
### Submission Process
Submit your MCP server to Tairon's MCP Supergraph in 4 simple steps:
**1. Prepare Your Server**
Ensure your server meets all requirements:
* ✅ MCP v1.0+ compliance
* ✅ All required endpoints implemented
* ✅ Comprehensive documentation
* ✅ Stable deployment (99%+ uptime)
***
**2. Submit Server Information**
```json
# Interactive submission
tairon submit
# Or provide details directly
tairon submit \
--name "My Price Oracle" \
--url "https://api.myprice.com" \
--category "defi" \
--description "Real-time crypto prices" \
--repository "https://github.com/user/my-oracle"
```
***
**3. Verification Process**
Tairon automatically verifies your server:
**Automated Checks (5-10 minutes):**
* MCP protocol compliance
* Endpoint availability
* Response format validation
* Basic security scan
**Manual Review (24-48 hours):**
* Code quality review (if open source)
* Documentation completeness
* Security assessment
* Community guidelines compliance
***
**4. Go Live**
Once approved, your server appears in the MCP Supergraph:
* Listed in relevant categories
* Available for testing via Live Inspector
* Monitored for uptime and performance
* Indexed for search discovery
***
### Submission Requirements
#### **Server Information**
**Basic Details:**
```bash
{
"name": "Server Name",
"description": "Detailed description of functionality",
"category": "defi|gaming|data|ai|tools",
"tags": ["price-feed", "ethereum", "real-time"],
"version": "1.0.0",
"mcpVersion": "1.0.0"
}
```
***
**Endpoints:**
```bash
{
"baseUrl": "https://api.yourserver.com",
"healthPath": "/health",
"capabilitiesPath": "/capabilities",
"executePath": "/execute"
}
```
***
**Maintainer Information:**
```bash
{
"name": "Your Name",
"email": "contact@yourserver.com",
"organization": "Your Company",
"website": "https://yourserver.com"
}
```
***
### **Documentation Requirements**
**API Documentation:**
* Complete function descriptions
* Parameter specifications with examples
* Return value schemas
* Error codes and handling
***
**Integration Examples:**
* JavaScript/Node.js examples
* Python examples
* cURL commands
* SDK integration samples
***
### **README.md Structure:**
````javascript
# Server Name
## Description
Brief description of what your server does.
## Functions
List of available functions with descriptions.
## Quick Start
```javascript
// Example usage
````
***
### Authentication
How to authenticate with your server.
***
### Rate Limits
Request limits and quotas.
***
### Support
How to get help or report issues.
#### **Submission Form Fields**
When submitting via the web interface, provide:
**Server Details:**
* **Name**: Display name for your server
* **Description**: Detailed explanation of functionality
* **Base URL**: Your server's base endpoint
* **Category**: Primary category (DeFi, Gaming, etc.)
* **Tags**: Searchable keywords
* **Version**: Current server version
**Code & Documentation:**
* **Repository URL**: Link to source code (if open source)
* **Documentation URL**: Link to API docs
* **License**: Software license type
* **Changelog**: Version history and updates
**Contact Information:**
* **Maintainer Name**: Primary contact person
* **Email**: Support email address
* **Organization**: Company or project name
* **Website**: Official website
**Optional Enhancements:**
* **Security Audit**: Upload audit reports
* **Performance Benchmarks**: Load testing results
* **Deployment Guide**: Self-hosting instructions
* **Business Model**: Pricing and usage terms
***
### **CLI Submission**
Use the Tairon CLI for programmatic submissions:
```javascript
# Login to Tairon
tairon auth login
# Initialize submission
tairon submit init
# This creates a tairon.config.json file:
{
"name": "My MCP Server",
"description": "Server description",
"category": "defi",
"tags": ["price", "oracle"],
"baseUrl": "https://api.myserver.com",
"repository": "https://github.com/user/server",
"maintainer": {
"name": "Developer Name",
"email": "dev@example.com"
}
}
# Submit server
tairon submit --config tairon.config.json
# Check submission status
tairon status submission-id
```
# Testing and Validation
### Live Inspector
The **Live Inspector** is Tairons flagship testing tool, providing real-time server validation directly in your browser.
***
#### **Features:**
**Function Explorer**
* Browse all available server functions
* View parameter schemas and examples
* See return value specifications
* Access function documentation
**Real-time Execution**
* Execute functions with custom parameters
* See results instantly
* Monitor execution time and performance
* Debug errors with detailed stack traces
**Code Generation**
* Auto-generate integration code
* Support for multiple languages
* Copy-paste ready snippets
* SDK and direct API examples
**Performance Analytics**
* Response time monitoring
* Success/failure rates
* Historical performance data
* Load testing capabilities
***
### **Using the Live Inspector:**
1. **Navigate to Server**: Go to any server page on Tairon
2. **Click "Test With Inspector"**: Opens the testing interface
3. **Select Function**: Choose from available functions
4. **Set Parameters**: Fill in required/optional parameters
5. **Execute**: Run the function and see results
6. **Analyze**: Review response data and performance
7. **Generate Code**: Copy integration examples
***
#### **Example Inspector Session:**
```javascript
// Function: getPrice
// Parameters: { "symbol": "ETH/USD", "source": "binance" }
// Execution Time: 145ms
// Result:
{
"price": 2345.67,
"timestamp": "2025-06-30T14:30:00Z",
"source": "binance",
"confidence": 0.99
}
// Generated JavaScript Code:
const client = new TaironClient();
const server = await client.getServer('price-oracle-v1');
const result = await server.call('getPrice', {
symbol: 'ETH/USD',
source: 'binance'
});
```
***
### Automated Testing
#### **Test Suite Categories**
**Functional Tests**
* Endpoint availability
* Response format validation
* Function execution
* Error handling
* Schema compliance
**Performance Tests**
* Response time benchmarks
* Throughput measurement
* Concurrent request handling
* Resource usage monitoring
* Load testing scenarios
**Security Tests**
* Authentication validation
* Input sanitization checks
* Rate limiting verification
* SSL/TLS configuration
* Vulnerability scanning
**Integration Tests**
* End-to-end workflows
* Multi-function sequences
* Error recovery
* State management
* Transaction handling
***
### **Running Tests**
**Via Web Interface:**
1. Go to server page
2. Click "Run Tests"
3. Select test suite
4. Monitor progress
5. Review results
***
**Via CLI**
```javascript
# Run basic tests
tairon test server-id
# Run comprehensive tests
tairon test server-id --suite comprehensive
# Custom test configuration
tairon test server-id --config test-config.json
# Example test-config.json:
{
"timeout": 30000,
"retries": 3,
"concurrent": 5,
"functions": [
{
"name": "getPrice",
"testCases": [
{ "symbol": "ETH/USD" },
{ "symbol": "BTC/USD" }
]
}
]
}
```
***
**Via SDK:**
```bash
import { TaironClient } from '@tairon/sdk';
const client = new TaironClient();
// Run tests programmatically
const testResults = await client.testing.runTests('server-id', {
suite: 'comprehensive',
timeout: 30000,
functions: ['getPrice', 'getHistoricalData']
});
console.log('Test Results:', testResults);
```
***
**Test Results Format**
```javascript
{
"testRunId": "test_123456",
"serverId": "srv_abcdef",
"status": "completed",
"startedAt": "2025-06-30T14:00:00Z",
"completedAt": "2025-06-30T14:05:30Z",
"duration": 330000,
"summary": {
"total": 45,
"passed": 42,
"failed": 2,
"skipped": 1,
"successRate": 93.3
},
"categories": {
"functional": { "passed": 15, "failed": 0 },
"performance": { "passed": 12, "failed": 1 },
"security": { "passed": 10, "failed": 1 },
"integration": { "passed": 5, "failed": 0 }
},
"details": [
{
"testName": "health_check_response_time",
"category": "performance",
"status": "passed",
"duration": 145,
"expected": "<500ms",
"actual": "145ms"
},
{
"testName": "function_execution_getPrice",
"category": "functional",
"status": "passed",
"duration": 230,
"result": {
"price": 2345.67,
"timestamp": "2025-06-30T14:00:00Z"
}
},
{
"testName": "rate_limiting",
"category": "security",
"status": "failed",
"duration": 5000,
"error": "Rate limiting not implemented",
"recommendation": "Implement request throttling"
}
]
}
```
***
### Continuous Monitoring
Tairon continuously monitors all listed servers:
**Health Checks:**
* Every 60 seconds
* Multi-region monitoring
* Uptime calculation
* Alert notifications
**Performance Tracking:**
* Response time monitoring
* Throughput measurement
* Error rate tracking
* Historical data storage
**Compliance Monitoring:**
* Protocol adherence
* Schema validation
* Security posture
* Best practices compliance
# Troubleshooting
Use this guide to quickly identify and fix common problems when working with Tairon MCP servers and APIs.
***
### Common Issues & Solutions
#### **1. Authentication Errors (`401 Unauthorized`)**
* **Cause:** Missing or invalid API key in the `Authorization` header.
* **Fix:**
* Verify your API key is correct and active.
* Include header: `Authorization: Bearer YOUR_API_KEY`.
* Do not expose API keys in client-side code.
***
#### **2. Server Not Found (`404 Not Found`)**
* **Cause:** Incorrect server ID or endpoint URL.
* **Fix:**
* Double-check the server ID used in your API call matches the directory.
* Ensure you’re calling the correct endpoint URL (e.g., `/servers/{serverId}`).
***
#### **3. Rate Limit Exceeded (`429 Too Many Requests`)**
* **Cause:** You’ve sent more requests than your plan allows.
* **Fix:**
* Review your API usage in your dashboard.
* Upgrade your plan if needed.
* Implement exponential backoff or retries in your client.
***
#### **4. Internal Server Error (`500 Internal Server Error`)**
* **Cause:** Server-side problems or unexpected errors.
* **Fix:**
* Retry the request after a short delay.
* Check if the issue persists; if yes, contact Tairon support with error details.
***
#### **5. Invalid Input or Request Schema (`422 Unprocessable Entity`)**
* **Cause:** Request payload does not match expected format.
* **Fix:**
* Verify JSON structure and required fields in your request body.
* Use the MCP Inspector to test requests interactively.
***
#### Additional Tips
* **Use the Tairon Inspector:** The Inspector lets you test servers live and view request/response details. It’s invaluable for debugging.
* **Check Server Status:** Some errors might result from server downtime. Use `/health` endpoints or Tairon dashboard to confirm uptime.
* **Logging & Monitoring:** Enable `/log` endpoints on your servers for detailed tracing if available.
* **Community & Support:** Join Tairon’s Telegram or contact support if you need help with complex issues.
# Team
Tairon is the on-chain **MCP Supergraph**, purpose-built for publishing, versioning, and managing data sources as oracles for AI, Robotics, IoT and RWA.\
Our team works across smart contracts, backend infrastructure, and developer tooling to make oracle coordination verifiable, secure, and permissioned on-chain.
***
### **Andrii Miloshin – CTO at Tairon**
[LinkedIn ↗](https://www.linkedin.com/in/miloshynandrew/)
Andrii leads protocol and system design across Tairon’s engineering stack. He’s responsible for building the onchain MCP registry and defining the core mechanics that govern how servers are published, validated, and managed over time.
* Architecting the lifecycle logic for MCP server publishing onchain.
* Designing Tairon’s permission model and metadata structures for scalable registration.
* Applying experience from Cerbo.ai and Dreamery across backend infra and ML systems.
* Driving long-term protocol design for verifiable server coordination.
***
### **Michael Tarchan – Blockchain Engineer at Tairon**
[LinkedIn ↗](https://www.linkedin.com/in/michael-tarchan/)
Michael develops the smart contracts that form Tairon’s onchain registry layer, enabling secure, permissioned flows for MCP server publishing and updates.
* Writing the smart contracts that handle MCP server registration, versioning, and access control.
* Implementing the onchain coordination logic that powers Tairon’s registry.
* Specializing in Solidity, EVM development, and contract security patterns.
* Supporting composable publishing mechanics across MCP-compatible clients.
***
### **Danyl Denk – Fullstack Engineer at Tairon**
[LinkedIn ↗](https://www.linkedin.com/in/danyl-denk-6499ba1b6/)
Danyl works on Tairon’s developer-facing surfaces, building the tools that make publishing MCP servers onchain seamless and accessible to engineers.
* Developing the Tairon dashboard and CLI for server onboarding and lifecycle operations.
* Supporting registry update flows, access delegation, and metadata publishing.
* Leveraging TypeScript, React, and backend services to deliver fast and intuitive UX.
* Focused on developer tooling that bridges protocol logic with practical workflows.
# Tokenomics
$TAIRO Contract Address: 0x9d5C1C400DC828a3409F9C209B83fF51A65d2A0E
# Token Utility
$TAIRO drives Tairon's MCP network, enabling publishing, infrastructure coordination, feature access, and protocol governance. Each link in the cycle is reinforced by both existing and upcoming capabilities.
### 1. Teams Publish MCP Servers
Teams register and operate MCP servers to host agents, automate logic, and expose endpoints via RPC. Registry actions like publishing, versioning, and scaling require $TAIRO.
**Upcoming Features:** → Marketplace for MCP modules and agent kits with dependency management → Automated publishing pipelines with CI/CD hooks and metrics dashboards → Batch configuration for large-scale deployments
### 2. Network Usage Grows
Servers handle agent traffic, scheduled logic, and expose APIs. As usage expands, reliable operators become even more important.
**Upcoming Features:** → Operator verification with uptime-based reputation scores → Real-time usage metrics and performance monitoring
### 3. Operators Earn $TAIRO
Operators of MCP servers earn token rewards tied to actual traffic and uptime. More consistent, high-availability infrastructure means greater rewards.
**Upcoming Features:** → Automated, onchain token payouts → Dynamic rewards scaling with volume → Staking requirements for operator verification and enhanced earning tiers
### 4. Token Used for Infrastructure Access & Tools
$TAIRO grants access to advanced registry features, custom server names, integrations, and supports scaling for complex operations.
**Upcoming Features:** → Custom domain registration for MCP servers and endpoints → Tiered access for observability, advanced publishing, and higher rate limits → Direct integrations with EVM chains, offchain APIs, and automation triggers
### 5. Governance & Community Funding
Token holders make and vote on proposals, shape upgrades, allocate funding, and set major protocol rules.
**Upcoming Features:** → Community-managed grant programs and bounties for open-source modules → Governance-based upgrades → Registry improvements decided by onchain proposals
### 6. Supergraph Expands with New Tools & Modules
Ecosystem-funded projects such as diagnostic utilities, templates, and new agent types are integrated into Tairon's registry, providing teams with a wider range of tools to build and deploy.
**Upcoming Features:** → MCP module and agent marketplace → Data marketplace for endpoint-generated datasets → Public goods tooling funded via community voting
Each new feature deepens $TAIRO's utility and accelerates the flywheel: publishing drives infrastructure demand, which increases rewards, unlocks new tools, and enables further governance and funding. This system keeps Tairon's participation, incentives, and innovation directly tied to token usage.
# FAQ
#### **What is Tairon?**
Tairon is the **oracle layer for AI, Robotics, IoT and RWA**. It connects blockchain data, protocols, and tools to intelligent systems, giving developers a single place to discover, test, and integrate live, verifiable on-chain data.
***
#### **How do I submit my MCP server to Tairon?**
You can submit your server via the Tairon web interface or CLI. You need to provide metadata such as server name, base URL, supported functions, contact info, and optionally audits or documentation. See the Server Submission Guidefor details.
***
#### **What makes a server “verified”?**
A verified server usually has public code repositories, audit reports, reproducible build logs, and passes Tairon’s live Inspector tests consistently.
***
#### **Can I submit private or internal servers?**
Yes, Tairon supports private server listings with scoped or whitelisted access for teams or test environments.
***
#### **How do I get an API key?**
Sign up on Tairon’s platform and navigate to your account dashboard to generate API keys for accessing protected endpoints.
***
#### **How can I monitor my server’s health?**
You can use the `/health` endpoint exposed by your MCP server, and Tairon provides uptime and response time monitoring on its dashboard.
***
#### **How do I handle errors when calling MCP servers?**
Refer to the Troubleshooting Guide for common error codes and solutions.
***
#### **Can I integrate Tairon APIs with my existing applications?**
Yes. Tairon provides REST APIs, SDKs for JavaScript and Python, and detailed documentation to help you integrate MCP servers seamlessly.
***
#### **Where can I get support?**
Email , or check the documentation for updates and announcements.
# Contact Tairon
Need help or have questions? Here’s how to reach us:
* **Email:**
* **GitHub:** Report issues or contribute
* **Sales:** (for business inquiries)
Follow us on social media for updates:
* Twitter: [@TaironAI](https://x.com/TaironAI)
