npm install @relayplane/sdk

yarn add @relayplane/sdk

import RelayPlane from '@relayplane/sdk';

// Zero-config magic - automatically picks best model
const result = await RelayPlane.ask("Explain quantum computing simply");
console.log(result.response.body);
console.log(result.reasoning.rationale); // See why this model was chosen

// Built-in examples for common tasks
const summary = await RelayPlane.examples.summarize(longText, { length: 'brief' });
const translation = await RelayPlane.examples.translate('Hello world', 'Spanish');
const review = await RelayPlane.examples.codeReview(myCode, { focus: 'security' });

// Smart retry with automatic model switching
const response = await RelayPlane.smartRetry({
  to: 'claude-3-7-sonnet-20250219',
  payload: { messages: [{ role: 'user', content: 'Complex task' }] }
}, {
  maxRetries: 3,
  confidenceThreshold: 0.9
});

# Set provider API keys in environment (choose what you need)
export ANTHROPIC_API_KEY="sk-ant-..."     # For Claude models
export OPENAI_API_KEY="sk-..."            # For GPT models  
export GOOGLE_API_KEY="AIza..."           # For Gemini models

# Use relay with your provider keys
import { relay } from '@relayplane/sdk';
const response = await relay({ 
  to: 'claude-3-7-sonnet-20250219', 
  payload: { messages: [{ role: 'user', content: 'Hello!' }] }
});

import { relay } from '@relayplane/sdk';

const response = await relay({
  to: 'claude-3-7-sonnet-20250219',     // Target model (auto-inferred to payload)
  payload: {                          // Model-specific payload  
    max_tokens: 1000,
    messages: [
      { role: 'user', content: 'Your prompt here' }
    ]
  },
  metadata: {                         // Optional tracking data
    user_id: 'user-123',
    session: 'session-456'
  }
});

console.log(response.relay_id);      // Unique request ID
console.log(response.latency_ms);    // Request latency
console.log(response.body);          // Model response

{
  "relay_id": "evt_123",           // Unique request identifier
  "status_code": 200,              // HTTP status from provider
  "latency_ms": 450,               // Total request latency
  "body": {...},                   // Provider response body
  "fallback_used": false           // Whether fallback was triggered
}

import { relay } from '@relayplane/sdk';

// Enable streaming in payload  
const response = await relay({
  to: 'claude-3-7-sonnet-20250219',
  payload: {
    max_tokens: 1000,
    stream: true,                    // Enable streaming
    messages: [
      { role: 'user', content: 'Write a poem about AI' }
    ]
  }
});

// Handle streaming response
for await (const chunk of response.stream) {
  process.stdout.write(chunk);
}
console.log('\nStreaming complete!');

fetch('https://api.relayplane.com/api/relay', {
  method: 'POST',
  headers: {
    'x-api-key': 'your-relay-api-key',
    'Content-Type': 'application/json',
    'Accept': 'text/event-stream'
  },
  body: JSON.stringify({
    to: 'claude-3-7-sonnet-20250219',
    payload: { stream: true, /* ... */ }
  })
}).then(response => {
  const reader = response.body.getReader();
  // Handle streamed chunks
});

import { relay, RelayError, RelayTimeoutError } from '@relayplane/sdk';

try {
  const response = await relay({
    to: 'claude-3-7-sonnet-20250219',
    payload: { /* ... */ }
  });
} catch (error) {
  if (error instanceof RelayTimeoutError) {
    console.log('Request timed out');
  } else if (error instanceof RelayError) {
    console.log('Relay error:', error.message);
    console.log('Error code:', error.code);
  } else {
    console.log('Unexpected error:', error);
  }
}

import { relay, RelayRateLimitError } from '@relayplane/sdk';

async function relayWithBackoff(request, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await relay(request);
    } catch (error) {
      if (error instanceof RelayRateLimitError && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

import { relay } from '@relayplane/sdk';

// Agent workflow with A2A communication
const workflow = await relay({
  to: 'claude-3-7-sonnet-20250219',
  payload: {
    max_tokens: 1000,
    messages: [
      { role: 'user', content: 'Analyze this data and pass results to the summarizer agent' }
    ]
  },
  metadata: {
    workflow_id: 'analysis-pipeline',
    next_agent: 'summarizer-v2'  // A2A routing
  }
});

import RelayPlane from '@relayplane/sdk';

const relayplane = new RelayPlane({
  apiKey: 'your-api-key',
  globalOptimize: {
    cacheStrategy: {
      type: 'hybrid',
      maxSize: '500MB',
      evictionPolicy: 'lru',
      compression: true
    },
    batchProcessing: {
      enabled: true,
      defaultConcurrency: 5,
      maxBatchSize: 100
    },
    timeoutSettings: {
      requestTimeoutMs: 30000,
      connectionTimeoutMs: 5000,
      retryTimeoutMs: 60000
    }
  }
});

# Transform data files with AI operations
npx @relayplane/cli transform -i data.csv -o "clean,analyze,summarize"

# Intelligent code review
npx @relayplane/cli review -f src/ -a security,performance,style

# Batch process multiple files  
npx @relayplane/cli batch -p "*.md" -o translate -c 3

# Execute complex workflows
npx @relayplane/cli workflow -t data-pipeline -i input.json