Integration GuideBuild on ML Bridge

// Create a task
const task = await client.tasks.create({
  modelId: 'model_123',
  input: { text: 'Analyze this sentiment' },
  computeRequirements: {
    gpuMemory: '8GB',
    maxExecutionTime: 300
  }
});

// Wait for completion
const result = await client.tasks
  .waitForCompletion(task.id);

// Cancel a task
await client.tasks.cancel(task.id);

// List available models
const models = await client.models.list({
  category: 'nlp',
  verified: true
});

// Register a new model (using IPFS CID)
const newModel = await client.models.register({
  name: 'My Custom Model',
  description: 'A fine-tuned model',
  category: 'nlp',
  ipfsCid: 'QmYwAPJzv5CZsnAzt8auVTLMk3NJT...',
  metadata: {
    framework: 'pytorch',
    version: '1.0.0'
  }
});

import asyncio
from mlbridge import AsyncMLBridge

async def main():
    client = AsyncMLBridge(api_key='your-key')

    # Create task
    task = await client.tasks.create({
        'model_id': 'model_123',
        'input': {'text': 'Hello world'}
    })

    # Wait for result
    result = await client.tasks
      .wait_for_completion(task['id'])
    print(f"Result: {result['output']}")

asyncio.run(main())

# Submit multiple tasks
tasks = client.tasks.create_batch([
    {'model_id': 'model_123',
     'input': {'text': 'Text 1'}},
    {'model_id': 'model_123',
     'input': {'text': 'Text 2'}},
    {'model_id': 'model_123',
     'input': {'text': 'Text 3'}}
])

# Wait for all to complete
results = client.tasks.wait_for_batch(
    [task['id'] for task in tasks],
    timeout=600
)

for result in results:
    print(result['output'])

import { ethers } from 'ethers';
import TaskManagerABI from './abis/TaskManager.json';

const provider = new ethers.providers.Web3Provider(
  window.ethereum
);
const signer = provider.getSigner();

const taskManager = new ethers.Contract(
  '0x1234...5678',
  TaskManagerABI,
  signer
);

// Submit a task
const tx = await taskManager.createTask(
  'model_123',
  ethers.utils.formatBytes32String('input'),
  ethers.utils.parseEther('0.01')
);

await tx.wait();

// Listen for task completion
taskManager.on('TaskCompleted',
  (taskId, result, cost) => {
    console.log(`Task ${taskId} completed`);
    console.log(`Result: ${result}`);
    console.log(`Cost: ${ethers.utils
      .formatEther(cost)} ETH`);
});

// Listen for new model registrations
modelRegistry.on('ModelRegistered',
  (modelId, owner, metadata) => {
    console.log(`New model: ${modelId}`);
    console.log(`Owner: ${owner}`);
});

const webhook = await client.webhooks.create({
  url: 'https://your-app.com/webhooks',
  events: [
    'task.completed',
    'task.failed'
  ],
  secret: 'your-webhook-secret'
});

console.log('Webhook ID:', webhook.id);

// Express.js handler
app.post('/webhooks', (req, res) => {
  const sig = req.headers['x-mlbridge-signature'];

  if (!verifySignature(req.body, sig, secret)) {
    return res.status(401).send('Invalid');
  }

  const event = req.body;

  switch (event.event) {
    case 'task.completed':
      handleCompletion(event.data);
      break;
    case 'task.failed':
      handleFailure(event.data);
      break;
  }

  res.status(200).send('OK');
});