LLMゲートウェイMCPサーバー

高性能AIエージェントからコスト効率の高いLLMへのインテリジェントな委任を可能にするモデルコンテキストプロトコル（MCP）サーバー

LLM ゲートウェイとは何ですか?

LLM Gatewayは、Claude 3.7 Sonnetのような高度なAIエージェントから、Gemini Flash 2.0 Liteのようなよりコスト効率の高いモデルへのインテリジェントなタスク委任を可能にするMCPネイティブサーバーです。複数の大規模言語モデル（LLM）プロバイダーへの統一されたインターフェースを提供し、コスト、パフォーマンス、品質を最適化します。

ビジョン：AI主導のリソース最適化

LLM Gatewayの根幹は、AIシステムとのインタラクションにおける根本的な変革です。すべてのタスクに単一の高価なモデルを使用するのではなく、以下のインテリジェントな階層構造を実現します。

Claude 3.7のような高度なモデルは、高レベルの推論、オーケストレーション、複雑なタスクに重点を置いています。
コスト効率の高いモデルは、日常的な処理、抽出、機械的なタスクを処理します
システム全体は、わずかなコストでトップクラスに近いパフォーマンスを実現します。

このアプローチは、人間の組織の仕組みを反映しています。つまり、専門家が複雑な決定を処理しながら、日常的なタスクをその特定のタスクに適切なスキルを持つ他の人に委任します。

MCPネイティブアーキテクチャ

このサーバーはモデルコンテキストプロトコル（MCP）に基づいて構築されており、ClaudeのようなAIエージェントと連携するように特別に設計されています。すべての機能はMCPツールを通じて公開されており、これらのエージェントから直接呼び出すことができるため、AI間の委任のためのシームレスなワークフローが実現します。

主な使用例: AIエージェントのタスク委任

LLM Gateway の主な設計目標は、Claude 3.7 Sonnet のような洗練された AI エージェントが、より安価なモデルにタスクをインテリジェントに委任できるようにすることです。

                          delegates to
┌─────────────┐ ────────────────────────► ┌───────────────────┐         ┌──────────────┐
│ Claude 3.7  │                           │   LLM Gateway     │ ───────►│ Gemini Flash │
│   (Agent)   │ ◄──────────────────────── │    MCP Server     │ ◄───────│ DeepSeek     │
└─────────────┘      returns results      └───────────────────┘         │ GPT-4o-mini  │
                                                                        └──────────────┘

ワークフローの例:

クロードは、文書を要約する必要があることを認識します（クロードとのコストのかかる操作）
クロードはMCPツールを介してこのタスクをLLMゲートウェイに委任します。
LLM Gateway は要約タスクを Gemini Flash にルーティングします (Claude よりも 10 ～ 20 倍安価)
要約はクロードに返され、より高度な推論と意思決定が行われる。
クロードは、その知性を本当に必要とするタスクに能力を集中させることができる。

この委任パターンにより、出力品質を維持しながら API コストを 70 ～ 90% 削減できます。

LLM ゲートウェイを使用する理由

🔄 AI間のタスク委任

最も強力な使用例は、高度な AI エージェントが日常的なタスクをより安価なモデルに委任できるようにすることです。

Claude 3.7 で初期ドキュメント要約に GPT-4o-mini を使用する
クロードは、データの抽出と変換に Gemini 2.0 Flash Light を使用します。
クロードが異なるプロバイダー間で多段階のワークフローをオーケストレーションできるようにする
クロードが特定のサブタスクごとに適切なモデルを選択できるようにする

💰 コスト最適化

高度なモデルのAPIコストは高額になる可能性があります。LLM Gatewayは、以下の方法でコスト削減に貢献します。

適切なタスクをより安価なモデルにルーティングする（例：$0.01/1Kトークン vs $0.15/1Kトークン）
冗長なAPI呼び出しを回避するための高度なキャッシュの実装
プロバイダー間のコストの追跡と最適化
コストを考慮したタスクルーティングの決定を可能にする

🔄 プロバイダーの抽象化

統合インターフェースでプロバイダーのロックインを回避:

OpenAI、Anthropic（Claude）、Google（Gemini）、DeepSeek の標準 API
一貫したパラメータ処理と応答フォーマット
アプリケーションコードを変更せずにプロバイダーを交換する機能
プロバイダー固有の停止や制限に対する保護

📄 大規模なドキュメント処理

大規模なドキュメントを効率的に処理します。

文書を意味的に意味のあるチャンクに分割する
複数のモデル間でチャンクを並列処理する
非構造化テキストから構造化データを抽出する
大量のテキストから要約と洞察を生成する

主な特徴

MCPプロトコル統合

ネイティブ MCP サーバー: AI エージェント統合のためのモデルコンテキストプロトコル上に構築
MCPツールフレームワーク: 標準化されたMCPツールを通じて公開されるすべての機能
ツール構成: ツールを組み合わせて複雑なワークフローを実現できます
ツール検出: ツールリストと機能検出のサポート

インテリジェントなタスク委任

タスクルーティング: タスクを分析し、適切なモデルにルーティングします
プロバイダーの選択: タスク要件に基づいてプロバイダーを選択します
コストパフォーマンスのバランス：コスト、品質、速度を最適化
委任追跡: 委任のパターンと結果を監視する

高度なキャッシュ

マルチレベルキャッシュ: 複数のキャッシュ戦略:
- 完全一致キャッシュ
- 意味的類似性キャッシュ
- タスク認識キャッシュ
永続キャッシュ: 高速なメモリ内アクセスを備えたディスクベースの永続性
キャッシュ分析: 節約額とヒット率を追跡

ドキュメントツール

スマートチャンキング: 複数のチャンキング戦略:
- トークンベースのチャンキング
- 意味的境界検出
- 構造解析
ドキュメント操作:
- 要約
- エンティティ抽出
- 質問生成
- バッチ処理

構造化データ抽出

JSON抽出: スキーマ検証を使用して構造化されたJSONを抽出します
表の抽出: 複数の形式で表を抽出します
キーと値の抽出: テキストからキーと値のペアを抽出します
セマンティックスキーマ推論: テキストからスキーマを生成する

トーナメントモード

コードとテキストのコンテスト: トーナメント形式のコンテストの運営をサポート
複数のモデル: 異なるモデルからの出力を同時に比較する
パフォーマンスメトリクス: モデルのパフォーマンスを評価および追跡する
結果の保存: トーナメントの結果を保管してさらに分析する

高度なベクトル演算

セマンティック検索: ドキュメント間で意味的に類似したコンテンツを検索します
ベクトルストレージ：ベクトル埋め込みの効率的な保存と検索
ハイブリッド検索: キーワード検索とセマンティック検索機能を組み合わせる
バッチ処理：大規模なデータセットを効率的に処理

使用例

クロード、LLMゲートウェイを使用してドキュメント分析を実施

この例では、Claude が LLM ゲートウェイを使用して、より安価なモデルにタスクを委任することでドキュメントを処理する方法を示します。

import asyncio
from mcp.client import Client

async def main():
    # Claude would use this client to connect to the LLM Gateway
    client = Client("http://localhost:8013")
    
    # Claude can identify a document that needs processing
    document = "... large document content ..."
    
    # Step 1: Claude delegates document chunking
    chunks_response = await client.tools.chunk_document(
        document=document,
        chunk_size=1000,
        method="semantic"
    )
    print(f"Document divided into {chunks_response['chunk_count']} chunks")
    
    # Step 2: Claude delegates summarization to a cheaper model
    summaries = []
    total_cost = 0
    for i, chunk in enumerate(chunks_response["chunks"]):
        # Use Gemini Flash (much cheaper than Claude)
        summary = await client.tools.summarize_document(
            document=chunk,
            provider="gemini",
            model="gemini-2.0-flash-lite",
            format="paragraph"
        )
        summaries.append(summary["summary"])
        total_cost += summary["cost"]
        print(f"Processed chunk {i+1} with cost ${summary['cost']:.6f}")
    
    # Step 3: Claude delegates entity extraction to another cheap model
    entities = await client.tools.extract_entities(
        document=document,
        entity_types=["person", "organization", "location", "date"],
        provider="openai",
        model="gpt-4o-mini"
    )
    total_cost += entities["cost"]
    
    print(f"Total delegation cost: ${total_cost:.6f}")
    # Claude would now process these summaries and entities using its advanced capabilities
    
    # Close the client when done
    await client.close()

if __name__ == "__main__":
    asyncio.run(main())

意思決定のための複数プロバイダーの比較

# Claude can compare outputs from different providers for critical tasks
responses = await client.tools.multi_completion(
    prompt="Explain the implications of quantum computing for cryptography.",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini", "temperature": 0.3},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307", "temperature": 0.3},
        {"provider": "gemini", "model": "gemini-2.0-pro", "temperature": 0.3}
    ]
)

# Claude could analyze these responses and decide which is most accurate
for provider_key, result in responses["results"].items():
    if result["success"]:
        print(f"{provider_key} Cost: ${result['cost']}")

コスト最適化されたワークフロー

# Claude can define and execute complex multi-stage workflows
workflow = [
    {
        "name": "Initial Analysis",
        "operation": "summarize",
        "provider": "gemini",
        "model": "gemini-2.0-flash-lite",
        "input_from": "original",
        "output_as": "summary"
    },
    {
        "name": "Entity Extraction",
        "operation": "extract_entities",
        "provider": "openai",
        "model": "gpt-4o-mini",
        "input_from": "original", 
        "output_as": "entities"
    },
    {
        "name": "Question Generation",
        "operation": "generate_qa",
        "provider": "deepseek",
        "model": "deepseek-chat",
        "input_from": "summary",
        "output_as": "questions"
    }
]

# Execute the workflow
results = await client.tools.execute_optimized_workflow(
    documents=[document],
    workflow=workflow
)

print(f"Workflow completed in {results['processing_time']:.2f}s")
print(f"Total cost: ${results['total_cost']:.6f}")

ドキュメントチャンク

大きなドキュメントを小さく管理しやすいサイズに分割するには:

large_document = "... your very large document content ..."

chunking_response = await client.tools.chunk_document(
    document=large_document,
    chunk_size=500,     # Target size in tokens
    overlap=50,         # Token overlap between chunks
    method="semantic"   # Or "token", "structural"
)

if chunking_response["success"]:
    print(f"Document divided into {chunking_response['chunk_count']} chunks.")
    # chunking_response['chunks'] contains the list of text chunks
else:
    print(f"Error: {chunking_response['error']}")

マルチプロバイダー補完

比較のために複数のプロバイダー/モデルから同時に同じプロンプトの補完を取得するには:

multi_response = await client.tools.multi_completion(
    prompt="What are the main benefits of using the MCP protocol?",
    providers=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-haiku-20240307"},
        {"provider": "gemini", "model": "gemini-2.0-flash-lite"}
    ],
    temperature=0.5
)

if multi_response["success"]:
    print("Multi-completion results:")
    for provider_key, result in multi_response["results"].items():
        if result["success"]:
            print(f"--- {provider_key} ---")
            print(f"Completion: {result['completion']}")
            print(f"Cost: ${result['cost']:.6f}")
        else:
            print(f"--- {provider_key} Error: {result['error']} ---")
else:
    print(f"Multi-completion failed: {multi_response['error']}")

構造化データ抽出（JSON）

テキストから特定の JSON スキーマに情報を抽出するには:

text_with_data = "User John Doe (john.doe@example.com) created an account on 2024-07-15. His user ID is 12345."

desired_schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "email": {"type": "string", "format": "email"},
        "creation_date": {"type": "string", "format": "date"},
        "user_id": {"type": "integer"}
    },
    "required": ["name", "email", "creation_date", "user_id"]
}

json_response = await client.tools.extract_json(
    document=text_with_data,
    json_schema=desired_schema,
    provider="openai", # Choose a provider capable of structured extraction
    model="gpt-4o-mini"
)

if json_response["success"]:
    print(f"Extracted JSON: {json_response['json_data']}")
    print(f"Cost: ${json_response['cost']:.6f}")
else:
    print(f"Error: {json_response['error']}")

検索拡張生成（RAG）クエリ

RAG を使用して質問するには、システムが回答を生成する前に関連するコンテキストを取得します (関連するドキュメントがインデックス付けされていると仮定)。

rag_response = await client.tools.rag_query( # Assuming a tool name like rag_query
    query="What were the key findings in the latest financial report?",
    # Parameters to control retrieval, e.g.:
    # index_name="financial_reports",
    # top_k=3, 
    provider="anthropic",
    model="claude-3-haiku-20240307" # Model to generate the answer based on context
)

if rag_response["success"]:
    print(f"RAG Answer:\n{rag_response['answer']}")
    # Potentially include retrieved sources: rag_response['sources']
    print(f"Cost: ${rag_response['cost']:.6f}")
else:
    print(f"Error: {rag_response['error']}")

融合検索（キーワード + セマンティック）

Marqo を使用してキーワードの関連性と意味的類似性を組み合わせたハイブリッド検索を実行するには:

fused_search_response = await client.tools.fused_search( # Assuming a tool name like fused_search
    query="impact of AI on software development productivity",
    # Parameters for Marqo index and tuning:
    # index_name="tech_articles",
    # keyword_weight=0.3, # Weight for keyword score (0.0 to 1.0)
    # semantic_weight=0.7, # Weight for semantic score (0.0 to 1.0)
    # top_n=5,
    # filter_string="year > 2023"
)

if fused_search_response["success"]:
    print(f"Fused Search Results ({len(fused_search_response['results'])} hits):")
    for hit in fused_search_response["results"]:
        print(f" - Score: {hit['_score']:.4f}, ID: {hit['_id']}, Content: {hit.get('text', '')[:100]}...")
else:
    print(f"Error: {fused_search_response['error']}")

ローカルテキスト処理

LLM API を呼び出さずにローカルのオフラインテキスト操作を実行するには:

# Assuming a tool that bundles local text functions
local_process_response = await client.tools.process_local_text( 
    text="  Extra   spaces   and\nnewlines\t here.  ",
    operations=[
        {"action": "trim_whitespace"},
        {"action": "normalize_newlines"},
        {"action": "lowercase"}
    ]
)

if local_process_response["success"]:
    print(f"Processed Text: '{local_process_response['processed_text']}'")
else:
    print(f"Error: {local_process_response['error']}")

モデルトーナメントの運営

特定のタスク (コード生成など) における複数のモデルの出力を比較するには:

# Assuming a tournament tool
tournament_response = await client.tools.run_model_tournament(
    task_type="code_generation",
    prompt="Write a Python function to calculate the factorial of a number.",
    competitors=[
        {"provider": "openai", "model": "gpt-4o-mini"},
        {"provider": "anthropic", "model": "claude-3-opus-20240229"}, # Higher-end model for comparison
        {"provider": "deepseek", "model": "deepseek-coder"}
    ],
    evaluation_criteria=["correctness", "efficiency", "readability"],
    # Optional: ground_truth="def factorial(n): ..." 
)

if tournament_response["success"]:
    print("Tournament Results:")
    # tournament_response['results'] would contain rankings, scores, outputs
    for rank, result in enumerate(tournament_response.get("ranking", [])):
        print(f"  {rank+1}. {result['provider']}/{result['model']} - Score: {result['score']:.2f}")
    print(f"Total Cost: ${tournament_response['total_cost']:.6f}")
else:
    print(f"Error: {tournament_response['error']}")

(ここにさらに多くのツールの例を追加できます...)

はじめる

インストール

# Install uv if you don't already have it:
curl -LsSf https://astral.sh/uv/install.sh | sh

# Clone the repository
git clone https://github.com/yourusername/llm_gateway_mcp_server.git
cd llm_gateway_mcp_server

# Install in venv using uv:
uv venv --python 3.13
source .venv/bin/activate
uv pip install -e ".[all]"

環境設定

API キーを使用して.envファイルを作成します。

# API Keys (at least one provider required)
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GEMINI_API_KEY=your_gemini_key
DEEPSEEK_API_KEY=your_deepseek_key

# Server Configuration
SERVER_PORT=8013
SERVER_HOST=127.0.0.1

# Logging Configuration
LOG_LEVEL=INFO
USE_RICH_LOGGING=true

# Cache Configuration
CACHE_ENABLED=true
CACHE_TTL=86400

サーバーの実行

# Start the MCP server
python -m llm_gateway.cli.main run

# Or with Docker
docker compose up

実行すると、サーバーはhttp://localhost:8013で利用できるようになります。

詳細設定

.envファイルは基本的なセットアップには便利ですが、LLM ゲートウェイでは、主に環境変数を通じて管理されるより詳細な構成オプションが提供されます。

サーバー構成

SERVER_HOST : (デフォルト: 127.0.0.1 ) サーバーがリッスンするネットワークインターフェース。すべてのインターフェースをリッスンするには0.0.0.0使用します（Dockerまたは外部アクセスに必要）。
SERVER_PORT : (デフォルト: 8013 ) サーバーがリッスンするポート。
API_PREFIX : (デフォルト: / ) API エンドポイントの URL プレフィックス。

ログ構成

LOG_LEVEL : (デフォルト: INFO ) ログの詳細度を制御します。オプション: DEBUG 、 INFO 、 WARNING 、 ERROR 、 CRITICAL 。
USE_RICH_LOGGING : (デフォルト: true ) カラフルでフォーマットされたコンソールログにはRichライブラリを使用します。プレーンテキストログの場合はfalseに設定します（ファイルリダイレクトや一部のログ集約システムに適しています）。
LOG_FORMAT : (オプション) カスタムログ形式文字列を指定します。
LOG_TO_FILE : (オプション、例: gateway.log ) ログを書き込むファイルへのパス。

キャッシュ構成

CACHE_ENABLED : (デフォルト: true ) キャッシュをグローバルに有効または無効にします。
CACHE_TTL : (デフォルト: 86400秒、つまり24時間) キャッシュされたアイテムのデフォルトのTTL（有効期限）。特定のツールによってこの値が上書きされる場合があります。
CACHE_TYPE : (デフォルト: memory ) キャッシュバックエンドの種類。オプションには、 memory 、 redis 、 diskcacheなどがあります。(注: サポートされているタイプについては、現在の実装を確認してください)。
CACHE_MAX_SIZE : (オプション) キャッシュのアイテムの最大数またはメモリサイズ。
REDIS_URL : ( CACHE_TYPE=redis場合は必須) Redis キャッシュサーバーの接続 URL (例: redis://localhost:6379/0 )。

プロバイダーのタイムアウトと再試行

PROVIDER_TIMEOUT : (デフォルト: 120秒) LLM プロバイダー API へのリクエストのデフォルトのタイムアウト。
PROVIDER_MAX_RETRIES : (デフォルト: 3 ) 失敗したプロバイダー要求の再試行回数のデフォルト (一時的なネットワークの問題やレート制限などにより)。
特定のプロバイダーのタイムアウト/再試行は、 OPENAI_TIMEOUT 、 ANTHROPIC_MAX_RETRIESなどの専用変数を介して構成できる場合があります (注: 現在の実装を確認してください)。

ツール固有の構成

一部のツールでは、設定用の独自の環境変数が使用される場合があります（例：融合検索のMARQO_URL 、デフォルトのチャンクパラメータなど）。各ツールのドキュメントまたはソースコードを参照してください。

サーバーを起動する前に、環境変数が正しく設定されていることを確認してください。変更を加えると、多くの場合サーバーの再起動が必要になります。

展開に関する考慮事項

pythonまたはdocker compose upを使用してサーバーを直接実行することは開発とテストには適していますが、より堅牢な展開や実稼働展開の場合は次の点を考慮してください。

1. バックグラウンドサービスとして実行する

ゲートウェイが継続的に実行され、障害発生時またはサーバーの再起動時に自動的に再起動されるようにするには、プロセスマネージャーを使用します。

**systemd (Linux):**プロセスを管理するためのサービスユニットファイル（例： /etc/systemd/system/llm-gateway.service ）を作成します。これによりsudo systemctl start|stop|restart|status llm-gatewayなどのコマンドが実行できるようになります。
supervisor ： Pythonで書かれた人気のプロセス制御システム。ゲートウェイプロセスを監視および制御するようにsupervisordを設定します。
Docker 再起動ポリシー: Docker (スタンドアロンまたは Compose) を使用する場合は、 docker runコマンドまたはdocker-compose.ymlファイルで適切な再起動ポリシー ( unless-stoppedまたはalwaysなど) を構成します。

2. リバースプロキシ（Nginx/Caddy/Apache）の使用

LLM ゲートウェイの前にリバースプロキシを配置することを強くお勧めします。

**HTTPS/SSL 終了:**プロキシは SSL 証明書 (例: Caddy で Let's Encrypt を使用するか、Nginx/Apache で Certbot を使用する) を処理して、クライアントとプロキシ間のトラフィックを暗号化できます。
**負荷分散:**高可用性またはパフォーマンスを実現するためにゲートウェイの複数のインスタンスを実行する必要がある場合、プロキシはそれらのインスタンス間でトラフィックを分散できます。
**パスルーティング:**外部パス (例: https://api.yourdomain.com/llm-gateway/ ) を内部ゲートウェイサーバー ( http://localhost:8013 ) にマップします。
**セキュリティヘッダー:**重要なセキュリティヘッダー (CSP、HSTS など) を追加します。
**バッファリング/キャッシュ:**一部のプロキシでは、追加の要求/応答バッファリングまたはキャッシュ機能が提供されます。

Nginx のlocationブロックの例 (簡略化):

location /llm-gateway/ {
    proxy_pass http://127.0.0.1:8013/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    # Add configurations for timeouts, buffering, etc.
}

3. コンテナオーケストレーション（Kubernetes/Swarm）

コンテナ化された環境にデプロイする場合:

**ヘルスチェック:**オーケストレーターがサービスの正常性を監視できるように、デプロイメントマニフェストにヘルスチェックエンドポイント (前述の/healthzなど) を実装して構成します。
**構成:**環境変数と API キーをイメージにハードコードしたり、 .envファイルのみに依存したりするのではなく、ConfigMaps と Secrets (Kubernetes) または同等のメカニズムを使用して安全に管理します。
**リソース制限:**安定したパフォーマンスを確保し、リソース不足を防ぐために、ゲートウェイコンテナーに適切な CPU およびメモリの要求/制限を定義します。
サービス検出: IP アドレスやホスト名をハードコーディングする代わりに、オーケストレーターのサービス検出メカニズムを利用します。

4. リソースの割り当て

特にメモリ内キャッシュを使用している場合や、大きなドキュメントやリクエストを処理している場合は、ホストマシンまたはコンテナに十分なRAMがあることを確認してください。
特に負荷が高い場合や複数の複雑な操作が同時に実行されている場合に、 CPU 使用率を監視します。

委任によるコスト削減

委任に LLM ゲートウェイを使用すると、大幅なコスト削減が実現します。

タスク	クロード 3.7 ダイレクト	より安価なLLMに委託	貯蓄
100ページの文書を要約する	4.50ドル	0.45ドル（ジェミニフラッシュ）	90%
50件のレコードからデータを抽出する	2.25ドル	0.35ドル（GPT-4o-mini）	84%
20個のコンテンツアイデアを生み出す	0.90ドル	0.12ドル（ディープシーク）	87%
1,000件の顧客からの問い合わせを処理	45.00ドル	7.50ドル（混合代表団）	83%

Claude が高度な推論とオーケストレーションに集中し、機械的なタスクをコスト効率の高いモデルに委任することで、高品質の出力を維持しながらこれらの節約を実現できます。

AI間の委任が重要な理由

AI 間の委任の戦略的重要性は、単純なコスト削減だけにとどまりません。

高度なAI機能を民主化する

Claude 3.7、GPT-4o などの強力なモデルを有効にして、効果的に委任できるようにすることで、次のことが可能になります。

高度なAI機能をわずかなコストで利用できるようにする
予算に制約のある組織でもトップレベルのAI機能を活用できるようにする
業界全体でAIリソースをより効率的に活用できるようにする

経済資源の最適化

AI 間の委任は、根本的な経済の最適化を表します。

複雑な推論、創造性、理解はトップレベルのモデルにのみ備わっている
日常的なデータ処理、抽出、およびより単純なタスクはコスト効率の高いモデルに移行します
システム全体は、わずかなコストでトップクラスに近いパフォーマンスを実現します。
APIコストは予測不可能な負債ではなく、管理された支出となる

持続可能なAIアーキテクチャ

このアプローチは、より持続可能な AI の使用を促進します。

ハイエンドの計算リソースの不要な消費を削減
要件に合わせて機能をマッチングする AI への階層型アプローチを作成します
トップレベルのモデルのみではコストがかかりすぎる実験作業を可能にする
ビジネスニーズに合わせて拡張できる、AI統合へのスケーラブルなアプローチを構築

技術進化の道筋

LLM ゲートウェイは、AI アプリケーションアーキテクチャにおける重要な進化を表しています。

モノリシックな AI 呼び出しから分散型のマルチモデルワークフローへの移行
複雑な処理パイプラインのAI駆動型オーケストレーションを実現
自身のリソース使用について推論できるAIシステムの基盤を構築する
インテリジェントな委任決定を行う自己最適化AIシステムの構築

AI効率の未来

LLM ゲートウェイは次のような未来を指し示します。

AIシステムは自らのリソース使用を積極的に管理し最適化する
より高性能なモデルは、AIエコシステム全体のインテリジェントなオーケストレーターとして機能します。
AIワークフローはますます洗練され、自己組織化される
組織はコスト効率の高い方法で AI のあらゆる機能を活用できます

効率的で自己組織化 AI システムのこのビジョンは、あらゆるタスクに単一のモデルを使用する現在のパターンを超えた、実用的な AI 展開の新たなフロンティアを表しています。

建築

MCP統合の仕組み

LLM ゲートウェイは、モデルコンテキストプロトコル上にネイティブに構築されています。

MCPサーバーコア:ゲートウェイは完全なMCPサーバーを実装します
ツール登録: すべての機能はMCPツールとして公開されます
ツールの呼び出し: クロードや他のAIエージェントはこれらのツールを直接呼び出すことができます
コンテキストパッシング: 結果はMCPの標準形式で返されます

これにより、Claude およびその他の MCP 互換エージェントとのシームレスな統合が保証されます。

コンポーネント図

┌─────────────┐         ┌───────────────────┐         ┌──────────────┐
│  Claude 3.7 │ ────────► LLM Gateway MCP   │ ────────► LLM Providers│
│   (Agent)   │ ◄──────── Server & Tools    │ ◄──────── (Multiple)   │
└─────────────┘         └───────┬───────────┘         └──────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Completion   │  │   Document    │  │  Extraction   │        │
│  │    Tools      │  │    Tools      │  │    Tools      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Optimization │  │  Core MCP     │  │  Analytics    │        │
│  │    Tools      │  │   Server      │  │    Tools      │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │    Cache      │  │    Vector     │  │    Prompt     │        │
│  │   Service     │  │   Service     │  │   Service     │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │  Tournament   │  │    Code       │  │   Multi-Agent │        │
│  │     Tools     │  │  Extraction   │  │  Coordination │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐        │
│  │   RAG Tools   │  │ Local Text    │  │  Meta Tools   │        │
│  │               │  │    Tools      │  │               │        │
│  └───────────────┘  └───────────────┘  └───────────────┘        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

委任のリクエストフロー

Claude が LLM Gateway にタスクを委任する場合:

クロードはMCPツールの呼び出しリクエストを送信します
ゲートウェイはMCPプロトコル経由でリクエストを受信する
適切なツールがリクエストを処理する
キャッシュサービスは結果がすでにキャッシュされているかどうかを確認します
キャッシュされていない場合は、最適化サービスが適切なプロバイダー/モデルを選択します。
プロバイダー層は選択されたLLM APIにリクエストを送信します。
レスポンスは標準化され、キャッシュされ、メトリクスが記録される
MCPサーバーは結果をクロードに返す

詳細な機能ドキュメント

プロバイダー統合

マルチプロバイダーサポート: 以下のファーストクラスのサポート:
- OpenAI (GPT-4o-mini、GPT-4o、GPT-4o mini)
- アントロピック（クロード3.7シリーズ）
- Google（Gemini Pro、Gemini Flash、Gemini Flash Light）
- DeepSeek (DeepSeek-Chat、DeepSeek-Reasoner)
- 新しいプロバイダーを追加するための拡張可能なアーキテクチャ
モデルマネジメント：
- タスク要件に基づく自動モデル選択
- モデルパフォーマンスの追跡
- プロバイダーの停止に対するフォールバックメカニズム

コスト最適化

インテリジェントルーティング: 次の基準に基づいてモデルを自動的に選択します。
- タスクの複雑さの要件
- 予算の制約
- パフォーマンスの優先順位
- 過去のパフォーマンスデータ
高度なキャッシュシステム:
- 複数のキャッシュ戦略（正確、セマンティック、タスクベース）
- タスクタイプごとに設定可能なTTL
- 高速なメモリ内検索を備えた永続キャッシュ
- キャッシュ統計とコスト削減の追跡

文書処理

スマートドキュメントチャンキング：
- 複数のチャンキング戦略（トークンベース、セマンティック、構造）
- コンテキスト保存のためのオーバーラップ構成
- 非常に大きな文書を効率的に処理します
ドキュメント操作:
- 要約（設定可能な形式）
- エンティティ抽出
- 質問と回答のペア生成
- 同時実行制御によるバッチ処理

データ抽出

構造化データ抽出：
- スキーマ検証によるJSON抽出
- テーブル抽出（JSON、CSV、Markdown形式）
- キーと値のペアの抽出
- 意味スキーマ推論

トーナメントとベンチマーク

モデルコンテスト：
- 異なるモデルと構成間で競争を実行する
- プロバイダ間のコード生成機能を比較する
- 統計的なパフォーマンスレポートを生成する
- 歴史的分析のための店舗競争結果
コード抽出:
- モデル応答からクリーンなコードを抽出する
- 抽出したコードを分析および検証する
- 複数のプログラミング言語のサポート

ベクトル演算

埋め込みサービス:
- 効率的なテキスト埋め込み生成
- APIコストを削減するためのキャッシュの埋め込み
- パフォーマンスのためのバッチ処理
セマンティック検索：
- 意味的に類似したコンテンツを見つける
- 設定可能な類似度しきい値
- 高速ベクトル演算
高度な融合検索（Marqo） :
- キーワードとセマンティック検索を組み合わせたMarqoを活用
- キーワードとベクトルの関連性の重み付けを調整可能
- 複雑なフィルタリングとファセットをサポート

検索拡張生成（RAG）

コンテキスト生成:
- LLMプロンプトに関連情報を追加します
- 事実の正確性を向上させ、幻覚を軽減する
- ベクター検索およびドキュメントストアと統合
ワークフロー統合:
- ドキュメント検索と生成タスクをシームレスに組み合わせる
- カスタマイズ可能な検索および生成戦略

ローカルテキスト処理

オフライン操作:
- API呼び出しなしでローカルで実行できるテキスト操作ツールを提供します
- クリーニング、フォーマット、基本的な分析の機能が含まれています
- LLM に送信する前のテキストの前処理や結果の後処理に役立ちます

メタ操作

内省と管理：
- サーバーの機能とステータスを照会するためのツール
- 構成やツール設定を動的に管理する機能が含まれる場合があります
- より複雑なエージェントインタラクションと自己管理を容易にします

システム機能

豊富なログ記録:
- リッチなコンソール出力
- さまざまな操作を表す絵文字インジケーター
- 詳細なコンテキスト情報
- ログエントリのパフォーマンスメトリック
ストリーミングサポート:
- すべてのプロバイダーで一貫したストリーミングインターフェース
- トークンごとの配信
- ストリーミング中のコスト追跡
健康モニタリング：
- エンドポイントのヘルスチェック (/healthz)
- リソース使用状況の監視
- プロバイダーの可用性追跡
- エラー率統計
コマンドラインインターフェース:
- サーバー管理のための豊富なインタラクティブ CLI
- コマンドラインからの直接ツール呼び出し
- 構成管理
- キャッシュとサーバーステータスの検査

ツールの使用例

このセクションでは、MCPクライアント（Claude 3.7など）がLLMゲートウェイが提供する特定のツールを呼び出す方法の例を示します。これらの例では、ゲートウェイに接続されたclientという名前の初期化されたmcp.client.Clientインスタンスがあることを前提としています。

基本的な完了

選択したプロバイダーから単純なテキスト補完を取得するには:

response = await client.tools.completion(
    prompt="Write a short poem about a robot learning to dream.",
    provider="openai",  # Or "anthropic", "gemini", "deepseek"
    model="gpt-4o-mini", # Specify the desired model
    max_tokens=100,
    temperature=0.7
)

if response["success"]:
    print(f"Completion: {response['completion']}")
    print(f"Cost: ${response['cost']:.6f}")
else:
    print(f"Error: {response['error']}")

文書の要約

コスト効率の高いモデルに委任する可能性のあるテキストの一部を要約すると、次のようになります。

document_text = "... your long document content here ..."

summary_response = await client.tools.summarize_document(
    document=document_text,
    provider="gemini",
    model="gemini-2.0-flash-lite", # Using a cheaper model for summarization
    format="bullet_points", # Options: "paragraph", "bullet_points"
    max_length=150 # Target summary length in tokens (approximate)
)

if summary_response["success"]:
    print(f"Summary:\n{summary_response['summary']}")
    print(f"Cost: ${summary_response['cost']:.6f}")
else:
    print(f"Error: {summary_response['error']}")

エンティティ抽出

テキストから特定の種類のエンティティを抽出するには:

text_to_analyze = "Apple Inc. announced its quarterly earnings on May 5th, 2024, reporting strong iPhone sales from its headquarters in Cupertino."

entity_response = await client.tools.extract_entities(
    document=text_to_analyze,
    entity_types=["organization", "date", "product", "location"],
    provider="openai",
    model="gpt-4o-mini"
)

if entity_response["success"]:
    print(f"Extracted Entities: {entity_response['entities']}")
    print(f"Cost: ${entity_response['cost']:.6f}")
else:
    print(f"Error: {entity_response['error']}")

最適化されたワークフローの実行

ゲートウェイが各ステップのモデル選択を最適化するマルチステップワークフローを実行するには:

doc_content = "... content for workflow processing ..."

workflow_definition = [
    {
        "name": "Summarize",
        "operation": "summarize_document",
        "provider_preference": "cost", # Prioritize cheaper models
        "params": {"format": "paragraph"},
        "input_from": "original",
        "output_as": "step1_summary"
    },
    {
        "name": "ExtractKeywords",
        "operation": "extract_keywords", # Assuming an extract_keywords tool exists
        "provider_preference": "speed",
        "params": {"count": 5},
        "input_from": "step1_summary",
        "output_as": "step2_keywords"
    }
]

workflow_response = await client.tools.execute_optimized_workflow(
    documents=[doc_content],
    workflow=workflow_definition
)

if workflow_response["success"]:
    print("Workflow executed successfully.")
    print(f"Results: {workflow_response['results']}") # Contains outputs like step1_summary, step2_keywords
    print(f"Total Cost: ${workflow_response['total_cost']:.6f}")
    print(f"Processing Time: {workflow_response['processing_time']:.2f}s")
else:
    print(f"Workflow Error: {workflow_response['error']}")

利用可能なツールの一覧表示（メタツール）

ゲートウェイに現在登録されていて利用可能なツールを動的に検出するには:

# Assuming a meta-tool for listing capabilities
list_tools_response = await client.tools.list_tools()

if list_tools_response["success"]:
    print("Available Tools:")
    for tool_name, tool_info in list_tools_response["tools"].items():
        print(f"- {tool_name}: {tool_info.get('description', 'No description')}")
        # You might also get parameters, etc.
else:
    print(f"Error listing tools: {list_tools_response['error']}")

実際のユースケース

AIエージェントオーケストレーション

Claude やその他の高度な AI エージェントは、LLM ゲートウェイを使用して次のことを行うことができます。

日常的なタスクをより安価なモデルに委任する
大規模なドキュメントを並列処理する
非構造化テキストから構造化データを抽出する
レビューと改善のためのドラフトを生成する

エンタープライズドキュメント処理

大規模なドキュメントコレクションを効率的に処理します。

ドキュメントを意味のあるチャンクに分割する
最適なモデル間で処理を分散する
大規模な構造化データを抽出する
ドキュメント間のセマンティック検索を実装する

調査と分析

研究チームは LLM Gateway を使用して次のことを行うことができます。

異なるモデルからの出力を比較する
研究論文を効率的に処理する
研究から構造化された情報を抽出する
トークンの使用状況を追跡し、研究予算を最適化する

モデルのベンチマークと選択

組織はトーナメント機能を使用して次のことを行うことができます。

異なるモデル間で制御された競争を実行する
定量的なパフォーマンス指標を生成する
モデル選択に関するデータ主導の意思決定
カスタムモデル評価フレームワークを構築する

セキュリティに関する考慮事項

LLM ゲートウェイを導入および運用する場合は、次のセキュリティ面を考慮してください。

API キー管理:
- ソースコードにAPI キーをハードコードしないでください。
- 環境変数 (ローカル開発の場合は.envファイル、本番環境の場合はシステム環境変数、または HashiCorp Vault、AWS Secrets Manager、GCP Secret Manager などのシークレット管理ツール) を使用します。
- .envファイル (使用されている場合) に厳密なファイル権限 (ゲートウェイを実行しているユーザーのみが読み取り可能) があることを確認します。
- キーを定期的にローテーションし、侵害された疑いのあるキーは直ちに取り消します。
ネットワークの露出とアクセス制御:
- デフォルトでは、サーバーは127.0.0.1にバインドされ、ローカル接続のみを許可します。外部に公開する予定がある場合のみ、 SERVER_HOST``0.0.0.0に変更し、適切な制御が確実に行われていることを確認してください。
- リバースプロキシ（Nginx、Caddyなど）を使用して着信接続を処理します。これにより、TLS/SSL暗号化の管理、アクセス制御（IP許可リストなど）の適用、ゲートウェイレベルの認証の追加などが可能になります。
- ホストマシンまたはネットワーク上でファイアウォールルールを適用し、信頼できるソース (リバースプロキシや特定の内部クライアントなど) からのSERVER_PORTへのアクセスのみを制限します。
認証と承認:
- ゲートウェイ自体にはユーザー認証機能が組み込まれていない場合があります。アクセス制御は通常、ネットワークセキュリティ（ファイアウォール、VPN）に依存し、リバースプロキシ（Basic認証、OAuth2プロキシなど）による認証が行われる場合もあります。
- 承認されたクライアント (信頼できる AI エージェントやアプリケーションなど) のみがゲートウェイエンドポイントにアクセスできることを確認します。
レート制限と不正使用防止:
- リバースプロキシレベルでレート制限を実装するか、専用のミドルウェアを使用して、サービス拒否攻撃や過剰な API 使用 (高額なコストが発生する可能性あり) を防止します。
入力検証:
- LLMの入力は通常テキストですが、ツールが入力を解釈して脆弱性につながる可能性がある場合（例：ツールが入力に基づいてコードを実行する場合など）には注意してください。ツールの機能に応じて、適切な方法で入力をサニタイズまたは検証してください。
依存関係のセキュリティ:
- 定期的に依存関係を更新し ( uv pip install --upgrade ...または同様のコマンド)、サードパーティライブラリの既知の脆弱性を修正します。
- 脆弱な依存関係を特定するには、セキュリティスキャンツール ( pip-auditや GitHub Dependabot アラートなど) の使用を検討してください。
ログ記録:
- DEBUGレベルのログでは、プロンプトと応答がすべて記録される可能性があり、機密情報が含まれる可能性がありますのでご注意ください。LOG_LEVEL LOG_LEVEL環境に合わせて適切に設定し、ログファイルに適切な権限が付与されていることを確認してください。

ライセンス

このプロジェクトは MIT ライセンスに基づいてライセンスされています - 詳細については LICENSE ファイルを参照してください。

謝辞

APIの基盤となるモデルコンテキストプロトコル
美しいターミナル出力のための豊富な機能
データ検証のためのPydantic
高速で信頼性の高い Python パッケージ管理のためのuv
API経由でモデルを公開しているすべてのLLMプロバイダー

Integrations