Unified LLM Interface - 統一LLMインターフェース - Refinire
Author: kitfactory
Description: 複数のLLMプロバイダーに対応した統一インターフェースライブラリ

コンテンツにスキップ

# Unified LLM Interface - 統一LLMインターフェース

Refinireの第一の柱である統一LLMインターフェースは、複数のLLMプロバイダーを同一のAPIで操作できる革新的な抽象化層です。

## 基本概念

複数のLLMプロバイダーを同じインターフェースで扱うことで、開発者はプロバイダー固有の実装に縛られることなく、自由に選択・切り替えできます。

### 環境変数の設定

各プロバイダーを使用するには、対応するAPIキーを環境変数に設定する必要があります：

プロバイダー | 環境変数 | 説明
--- | --- | ---
OpenAI | `OPENAI_API_KEY` | OpenAI APIキー
Anthropic | `ANTHROPIC_API_KEY` | Anthropic Claude APIキー
Google | `GOOGLE_API_KEY` | Google Gemini APIキー
Ollama | `OLLAMA_BASE_URL` | Ollamaサーバーアドレス（デフォルト: http://localhost:11434）

#### 環境変数設定例

Windows (PowerShell):

    $env:OPENAI_API_KEY = "sk-your-openai-api-key"
    $env:ANTHROPIC_API_KEY = "sk-ant-your-anthropic-api-key"
    $env:GOOGLE_API_KEY = "your-google-api-key"
    $env:OLLAMA_BASE_URL = "http://localhost:11434"

macOS/Linux (Bash):

    export OPENAI_API_KEY="sk-your-openai-api-key"
    export ANTHROPIC_API_KEY="sk-ant-your-anthropic-api-key"
    export GOOGLE_API_KEY="your-google-api-key"
    export OLLAMA_BASE_URL="http://localhost:11434"

Python内での設定:

    import os

    # プログラム内で環境変数を設定
    os.environ["OPENAI_API_KEY"] = "sk-your-openai-api-key"
    os.environ["ANTHROPIC_API_KEY"] = "sk-ant-your-anthropic-api-key"
    os.environ["GOOGLE_API_KEY"] = "your-google-api-key"
    os.environ["OLLAMA_BASE_URL"] = "http://localhost:11434"

### 統一インターフェース

環境変数を設定後、すべてのプロバイダーが同じAPIで利用できます：

    from refinire import get_llm

    # 同じインターフェースで異なるプロバイダーにアクセス
    llm_openai = get_llm("gpt-4o-mini")
    llm_anthropic = get_llm("claude-3-sonnet")
    llm_google = get_llm("gemini-pro")
    llm_ollama = get_llm("llama3.1:8b")

    # すべて同じメソッドで操作
    response = llm_openai.complete("こんにちは")

## 簡単な事例

### 1. 基本的なLLM使用

    from refinire import get_llm

    # LLMの取得
    llm = get_llm("gpt-4o-mini")

    # テキスト生成
    response = llm.complete("AIの将来性について教えてください")
    print(response)

### 2. 環境変数設定の確認

    import os
    from refinire import get_llm

    def check_api_setup():
        """API設定の確認"""
        providers_check = {
            "OpenAI": "OPENAI_API_KEY",
            "Anthropic": "ANTHROPIC_API_KEY",
            "Google": "GOOGLE_API_KEY",
            "Ollama": "OLLAMA_BASE_URL"
        }

        for provider, env_var in providers_check.items():
            if env_var in os.environ:
                print(f"✓ {provider}: 設定済み")
            else:
                print(f"✗ {provider}: {env_var} が未設定")

    # API設定確認
    check_api_setup()

### 3. プロバイダー切り替え

    def test_providers():
        """利用可能なプロバイダーでテスト実行"""
        providers = [
            ("gpt-4o-mini", "OpenAI"),
            ("claude-3-haiku-20240307", "Anthropic"),
            ("gemini-1.5-flash", "Google"),
            ("llama3.1:8b", "Ollama")
        ]
        question = "量子コンピューティングとは何ですか？"

        for model, provider in providers:
            try:
                llm = get_llm(model)
                response = llm.complete(question)
                print(f"✓ {provider} ({model}): {response[:100]}...")
            except Exception as e:
                print(f"✗ {provider} ({model}): エラー - {e}")

    # プロバイダーテスト実行
    test_providers()

## 中級事例

### 3. 戦略的プロバイダー使い分け

    class MultiProviderService:
        def __init__(self):
            self.fast_llm = get_llm("gpt-4o-mini")      # 高速
            self.smart_llm = get_llm("gpt-4o")          # 高性能
            self.creative_llm = get_llm("claude-3-sonnet")  # 創造性

        def quick_answer(self, question: str) -> str:
            return self.fast_llm.complete(f"簡潔に: {question}")

        def detailed_analysis(self, topic: str) -> str:
            return self.smart_llm.complete(f"詳細分析: {topic}")

        def creative_writing(self, theme: str) -> str:
            return self.creative_llm.complete(f"創作: {theme}")

### 4. フォールバック機構

    class RobustLLMService:
        def __init__(self, provider_hierarchy):
            self.provider_hierarchy = provider_hierarchy
            self.llms = {p: get_llm(p) for p in provider_hierarchy}

        def complete_with_fallback(self, prompt: str):
            for provider in self.provider_hierarchy:
                try:
                    return self.llms[provider].complete(prompt), provider
                except Exception as e:
                    print(f"{provider} 失敗: {e}")
            raise Exception("全プロバイダーで失敗")

## 高度な事例

### 5. インテリジェントプロバイダー選択

    from enum import Enum

    class TaskType(Enum):
        CREATIVE = "creative"
        TECHNICAL = "technical"
        CASUAL = "casual"

    class SmartProviderSelector:
        def __init__(self):
            self.profiles = {
                "gpt-4o-mini": {"strengths": [TaskType.CASUAL], "cost": 1},
                "claude-3-sonnet": {"strengths": [TaskType.CREATIVE], "cost": 2},
                "gpt-4o": {"strengths": [TaskType.TECHNICAL], "cost": 3}
            }

        def classify_task(self, prompt: str) -> TaskType:
            if any(word in prompt for word in ["物語", "創作"]):
                return TaskType.CREATIVE
            elif any(word in prompt for word in ["分析", "技術"]):
                return TaskType.TECHNICAL
            return TaskType.CASUAL

        def select_provider(self, prompt: str, priority="balanced"):
            task_type = self.classify_task(prompt)
            # 最適なプロバイダーを選択するロジック
            for provider, profile in self.profiles.items():
                if task_type in profile["strengths"]:
                    return provider
            return "gpt-4o-mini"  # デフォルト

## メリット

- プロバイダー透明性: 統一されたAPIで複数プロバイダー操作
- 移行容易性: 最小限の変更でプロバイダー切り替え
- フォールバック: 堅牢なエラーハンドリング
- 最適化: タスクに応じた自動プロバイダー選択

統一LLMインターフェースにより、開発者はプロバイダーの詳細に縛られず、AIアプリケーションの価値創造に集中できます。