Learn how to work with different AI models from various providers while using Metorial integrations.

Why Use Multiple Models?

Different AI models have different strengths:

• GPT-4: Excellent reasoning and instruction following
• Claude: Strong at analysis and nuanced tasks
• Gemini: Multimodal capabilities and competitive performance
• Open-source models: Cost-effective for simpler tasks

With Metorial, you can use any AI provider while maintaining access to the same 600+ integrations.

Switching Between Models

The AI SDK makes it easy to switch between providers:

import { openai } from '@ai-sdk/openai';
import { anthropic } from '@ai-sdk/anthropic';
import { google } from '@ai-sdk/google';

// Use OpenAI
const gpt4Result = await generateText({
  model: openai('gpt-4'),
  messages,
  tools: session.tools
});

// Use Anthropic
const claudeResult = await generateText({
  model: anthropic('claude-3-opus-20240229'),
  messages,
  tools: session.tools
});

// Use Google
const geminiResult = await generateText({
  model: google('gemini-1.5-pro'),
  messages,
  tools: session.tools
});

Model Selection Based on Task

Choose models dynamically based on task requirements:

function selectModel(taskType: string) {
  switch (taskType) {
    case 'complex-reasoning':
      return openai('gpt-4');
    case 'analysis':
      return anthropic('claude-3-opus-20240229');
    case 'quick-response':
      return openai('gpt-3.5-turbo');
    default:
      return openai('gpt-4');
  }
}

await metorial.withProviderSession(
  metorialAiSdk,
  { serverDeployments: [process.env.METORIAL_DEPLOYMENT_ID!] },
  async session => {
    const result = await generateText({
      model: selectModel('complex-reasoning'),
      messages,
      tools: session.tools
    });
    
    return result.text;
  }
);

Fallback Strategy

Implement fallbacks for reliability:

async function generateWithFallback(
  messages: any[],
  tools: any[]
) {
  const models = [
    openai('gpt-4'),
    anthropic('claude-3-opus-20240229'),
    openai('gpt-3.5-turbo')
  ];
  
  for (const model of models) {
    try {
      const result = await generateText({
        model,
        messages,
        tools,
        maxToolRoundtrips: 5
      });
      
      return result;
    } catch (error) {
      console.error(`Model ${model} failed, trying next...`);
      continue;
    }
  }
  
  throw new Error('All models failed');
}

await metorial.withProviderSession(
  metorialAiSdk,
  { serverDeployments: [process.env.METORIAL_DEPLOYMENT_ID!] },
  async session => {
    return await generateWithFallback(messages, session.tools);
  }
);

Cost Optimization

Use cheaper models for simpler tasks:

async function generateCostEffective(
  complexity: 'simple' | 'medium' | 'complex',
  messages: any[],
  tools: any[]
) {
  const modelMap = {
    simple: openai('gpt-3.5-turbo'),
    medium: openai('gpt-4'),
    complex: openai('gpt-4-turbo')
  };
  
  return await generateText({
    model: modelMap[complexity],
    messages,
    tools
  });
}

Model-Specific Configuration

Different models may need different configurations:

function getModelConfig(modelType: string) {
  const configs = {
    'gpt-4': {
      maxToolRoundtrips: 5,
      temperature: 0.7
    },
    'claude-3-opus': {
      maxToolRoundtrips: 5,
      temperature: 0.8
    },
    'gpt-3.5-turbo': {
      maxToolRoundtrips: 3,
      temperature: 0.5
    }
  };
  
  return configs[modelType] || configs['gpt-4'];
}

Best Practices

1. Test each model: Different models may interpret tools differently
2. Monitor costs: Track usage per model to optimize spending
3. Set timeouts: Some models are slower than others
4. Document choices: Note why specific models are used for specific tasks
5. Version control: Pin model versions in production

Provider Setup

Make sure to install the necessary AI SDK providers:

# For OpenAI
npm install @ai-sdk/openai

# For Anthropic
npm install @ai-sdk/anthropic

# For Google
npm install @ai-sdk/google

And configure their API keys:

# .env.local
OPENAI_API_KEY=your-openai-key
ANTHROPIC_API_KEY=your-anthropic-key
GOOGLE_GENERATIVE_AI_API_KEY=your-google-key
METORIAL_API_KEY=your-metorial-key

The Power of Metorial

The beauty of using Metorial is that all your integrations work with any AI provider. Switch models freely without rebuilding your integration layer—Metorial handles the complexity so you can focus on choosing the best model for each task.