Setting Up Providers

Setting Up Providers

This guide will help you set up and configure AI providers in UniCraft to start routing your AI requests.

Prerequisites

Before setting up providers, you’ll need:

• API keys for the providers you want to use
• UniCraft account
• Basic understanding of the providers you’re integrating

Supported Providers

UniCraft supports the following AI providers:

OpenAI

• Models: GPT-4, GPT-3.5 Turbo, GPT-4 Turbo, Embeddings
• API: OpenAI API
• Documentation: OpenAI API Docs

Anthropic

• Models: Claude 3 Haiku, Claude 3 Sonnet, Claude 3 Opus
• API: Anthropic API
• Documentation: Anthropic API Docs

Google

• Models: Gemini Pro, Gemini Pro Vision, PaLM 2
• API: Google AI Studio API
• Documentation: Google AI Docs

Other Providers

• Cohere
• Hugging Face
• Custom API endpoints

Step 1: Obtain API Keys

OpenAI

1. Visit OpenAI Platform
2. Sign up or log in to your account
3. Navigate to API Keys section
4. Click Create new secret key
5. Copy and securely store your API key

Anthropic

1. Visit Anthropic Console
2. Sign up or log in to your account
3. Navigate to API Keys section
4. Click Create Key
5. Copy and securely store your API key

Google

1. Visit Google AI Studio
2. Sign in with your Google account
3. Navigate to Get API Key
4. Create a new API key
5. Copy and securely store your API key

Step 2: Add Providers via Dashboard

Using the Web Interface

1. Log into UniCraft Dashboard

   • Navigate to your UniCraft dashboard
   • Log in with your credentials

2. Access Provider Settings

   • Click on Settings in the sidebar
   • Select Providers from the settings menu

3. Add New Provider

   • Click Add Provider button
   • Select the provider type from the dropdown

4. Configure Provider

   • Enter a descriptive name for the provider
   • Paste your API key
   • Select which models to enable
   • Set provider priority (1 = highest priority)
   • Configure rate limits if needed

5. Test Connection

   • Click Test Connection to verify the setup
   • Review the test results

6. Save Configuration

   • Click Save to add the provider

Example Configuration

{
  "name": "OpenAI Production",
  "type": "openai",
  "api_key": "sk-...",
  "models": ["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"],
  "priority": 1,
  "enabled": true,
  "rate_limits": {
    "requests_per_minute": 60,
    "tokens_per_minute": 100000
  }
}

Step 3: Add Providers via API

Using the UniCraft API

// Add OpenAI provider
const openaiProvider = await unicraft.providers.create({
  name: "OpenAI Production",
  type: "openai",
  api_key: process.env.OPENAI_API_KEY,
  models: ["gpt-4", "gpt-3.5-turbo"],
  priority: 1,
  enabled: true,
  rate_limits: {
    requests_per_minute: 60,
    tokens_per_minute: 100000,
  },
});

// Add Anthropic provider
const anthropicProvider = await unicraft.providers.create({
  name: "Anthropic Production",
  type: "anthropic",
  api_key: process.env.ANTHROPIC_API_KEY,
  models: ["claude-3-sonnet", "claude-3-haiku"],
  priority: 2,
  enabled: true,
  rate_limits: {
    requests_per_minute: 50,
    tokens_per_minute: 80000,
  },
});

// Add Google provider
const googleProvider = await unicraft.providers.create({
  name: "Google Production",
  type: "google",
  api_key: process.env.GOOGLE_API_KEY,
  models: ["gemini-pro"],
  priority: 3,
  enabled: true,
  rate_limits: {
    requests_per_minute: 100,
    tokens_per_minute: 120000,
  },
});

Step 4: Configure Environment Variables

For security, store your API keys as environment variables:

.env File

# OpenAI
OPENAI_API_KEY=sk-your-openai-key-here

# Anthropic
ANTHROPIC_API_KEY=sk-ant-your-anthropic-key-here

# Google
GOOGLE_API_KEY=your-google-api-key-here

# UniCraft
UNICRAFT_API_KEY=your-unicraft-api-key-here

Using Environment Variables in Code

const providers = [
  {
    name: "OpenAI",
    type: "openai",
    api_key: process.env.OPENAI_API_KEY,
    models: ["gpt-4", "gpt-3.5-turbo"],
  },
  {
    name: "Anthropic",
    type: "anthropic",
    api_key: process.env.ANTHROPIC_API_KEY,
    models: ["claude-3-sonnet", "claude-3-haiku"],
  },
];

Step 5: Test Provider Configuration

Test Individual Providers

// Test OpenAI provider
const openaiTest = await unicraft.providers.test({
  provider_id: "openai-production",
  test_request: {
    messages: [{ role: "user", content: "Hello, world!" }],
    model: "gpt-3.5-turbo",
    max_tokens: 10,
  },
});

console.log("OpenAI Test Result:", openaiTest);

Test All Providers

// Test all enabled providers
const allProviders = await unicraft.providers.list();
const testResults = [];

for (const provider of allProviders) {
  if (provider.enabled) {
    const result = await unicraft.providers.test({
      provider_id: provider.id,
      test_request: {
        messages: [{ role: "user", content: "Test message" }],
        model: provider.models[0],
        max_tokens: 10,
      },
    });
    testResults.push({ provider: provider.name, result });
  }
}

console.log("All Provider Tests:", testResults);

Step 6: Configure Provider Settings

Rate Limiting

Set appropriate rate limits for each provider:

const rateLimits = {
  openai: {
    requests_per_minute: 60,
    requests_per_hour: 1000,
    tokens_per_minute: 100000,
    tokens_per_hour: 1000000,
  },
  anthropic: {
    requests_per_minute: 50,
    requests_per_hour: 800,
    tokens_per_minute: 80000,
    tokens_per_hour: 800000,
  },
};

Model Configuration

Configure which models to use from each provider:

const modelConfig = {
  openai: {
    default_model: "gpt-3.5-turbo",
    available_models: ["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"],
    model_preferences: {
      content_generation: "gpt-4",
      simple_qa: "gpt-3.5-turbo",
      code_generation: "gpt-4",
    },
  },
};

Failover Configuration

Set up automatic failover between providers:

const failoverConfig = {
  enabled: true,
  primary_provider: "openai",
  fallback_providers: ["anthropic", "google"],
  retry_attempts: 3,
  retry_delay: 1000,
  circuit_breaker: {
    enabled: true,
    failure_threshold: 5,
    recovery_timeout: 30000,
  },
};

Step 7: Monitor Provider Health

Health Check Configuration

const healthCheck = {
  enabled: true,
  interval: 60000, // Check every minute
  timeout: 5000, // 5 second timeout
  endpoints: {
    openai: "https://api.openai.com/v1/models",
    anthropic: "https://api.anthropic.com/v1/messages",
    google: "https://generativelanguage.googleapis.com/v1/models",
  },
};

Monitoring Dashboard

Monitor provider health in the UniCraft dashboard:

• Provider availability status
• Response time metrics
• Error rate tracking
• Usage statistics

Troubleshooting

Common Issues

1. Invalid API Key

   • Verify the API key is correct
   • Check if the key has expired
   • Ensure the key has proper permissions

2. Rate Limit Exceeded

   • Check your rate limit configuration
   • Monitor usage patterns
   • Consider upgrading your provider plan

3. Model Not Available

   • Verify the model is available in your provider account
   • Check if you have access to the model
   • Update your model configuration

4. Network Issues

   • Check your internet connection
   • Verify firewall settings
   • Test provider endpoints directly

Debug Mode

Enable debug mode to troubleshoot provider issues:

const response = await unicraft.chat.completions.create({
  messages: [{ role: "user", content: "Hello" }],
  debug: true,
});

console.log("Provider used:", response.debug.provider);
console.log("Model used:", response.debug.model);
console.log("Response time:", response.debug.response_time);
console.log("Provider status:", response.debug.provider_status);

Best Practices

1. Use Environment Variables: Never hardcode API keys in your code
2. Set Appropriate Rate Limits: Configure rate limits based on your usage patterns
3. Monitor Provider Health: Regularly check provider status and performance
4. Implement Failover: Always have backup providers configured
5. Test Thoroughly: Test all providers before deploying to production
6. Regular Reviews: Periodically review and update provider configurations
7. Security: Use encrypted storage for API keys and implement proper access controls

Next Steps

After setting up your providers:

1. Configure smart routing to optimize model selection
2. Set up monitoring and alerts
3. Test your configuration with various request types
4. Implement failover and load balancing
5. Monitor usage and optimize based on patterns