Copilot API完全ガイド：料金・使い方・連携方法まで徹底解説

# .envファイルに記載
COPILOT_API_KEY=your_api_key_here

# .gitignoreに追加
.env

import os
from dotenv import load_dotenv

# .envファイルから環境変数を読み込み
load_dotenv()

# APIキーを取得
api_key = os.getenv('COPILOT_API_KEY’)

import os
import requests
from typing import Dict, Optional

class CopilotAPIClient:
“""Copilot APIクライアントクラス"""

def __init__(self, api_key: str):
“""
初期化
Args:
api_key: Copilot API認証キー
“""
self.api_key = api_key
self.base_url = “https://api.github.com/copilot"
self.headers = {
“Authorization": f"Bearer {self.api_key}",
“Content-Type": “application/json"
}

def generate_code(self, prompt: str) -> Optional[Dict]:
“""
コード生成リクエストを送信
Args:
prompt: コード生成のためのプロンプト
Returns:
API レスポンス（辞書形式）
“""
url = f"{self.base_url}/completions"
payload = {
“prompt": prompt,
“max_tokens": 150
}

try:
response = requests.post(
url,
json=payload,
headers=self.headers,
timeout=30
)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"APIリクエストエラー: {e}")
return None

# 使用例
if __name__ == “__main__":
# 環境変数からAPIキーを取得
api_key = os.getenv('COPILOT_API_KEY’)

# クライアントを初期化
client = CopilotAPIClient(api_key)

# コード生成をリクエスト
result = client.generate_code(“Pythonでフィボナッチ数列を計算する関数")

if result:
print(“生成されたコード:")
print(result)

const axios = require('axios’);

class CopilotAPIClient {
constructor(apiKey) {
this.apiKey = apiKey;
this.baseUrl = 'https://api.github.com/copilot’;
this.headers = {
'Authorization’: `Bearer ${this.apiKey}`,
'Content-Type’: 'application/json’
};
}

async generateCode(prompt) {
const url = `${this.baseUrl}/completions`;
const payload = {
prompt: prompt,
max_tokens: 150
};

try {
const response = await axios.post(url, payload, {
headers: this.headers,
timeout: 30000
});
return response.data;
} catch (error) {
console.error('APIリクエストエラー:’, error.message);
return null;
}
}
}

// 使用例
(async () => {
const apiKey = process.env.COPILOT_API_KEY;
const client = new CopilotAPIClient(apiKey);

const result = await client.generateCode(
'JavaScriptで配列をソートする関数’
);

if (result) {
console.log('生成されたコード:’, result);
}
})();

const express = require('express’);
const axios = require('axios’);

const app = express();
app.use(express.json());

// Copilot APIエンドポイント
const COPILOT_API_URL = 'https://api.github.com/copilot/completions’;
const API_KEY = process.env.COPILOT_API_KEY;

// コード生成エンドポイント
app.post('/api/generate-code’, async (req, res) => {
try {
const { prompt } = req.body;

// 入力検証
if (!prompt) {
return res.status(400).json({
error: 'プロンプトが必要です’
});
}

// Copilot APIへリクエスト
const response = await axios.post(
COPILOT_API_URL,
{
prompt: prompt,
max_tokens: 200,
temperature: 0.7
},
{
headers: {
'Authorization’: `Bearer ${API_KEY}`,
'Content-Type’: 'application/json’
}
}
);

// 成功レスポンスを返す
res.json({
success: true,
code: response.data.choices[0].text
});

} catch (error) {
console.error('エラー:’, error.message);
res.status(500).json({
error: 'コード生成に失敗しました’
});
}
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`サーバーがポート${PORT}で起動しました`);
});

import time
from functools import wraps

def rate_limit(max_calls_per_minute=60):
“""
レート制限デコレータ
“""
min_interval = 60.0 / max_calls_per_minute
last_called = [0.0]

def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
elapsed = time.time() – last_called[0] left_to_wait = min_interval – elapsed

if left_to_wait > 0:
time.sleep(left_to_wait)

result = func(*args, **kwargs)
last_called[0] = time.time()
return result
return wrapper
return decorator

class OptimizedCopilotClient:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = “https://api.github.com/copilot"

@rate_limit(max_calls_per_minute=50)
def generate_code(self, prompt):
“""レート制限を考慮したコード生成"""
# API呼び出し処理
pass

def batch_generate_code(prompts, batch_size=5):
“""
複数のプロンプトをバッチ処理
“""
results = []

for i in range(0, len(prompts), batch_size):
batch = prompts[i:i + batch_size]

# バッチリクエストを作成
batch_request = {
“requests": [
{“prompt": prompt} for prompt in batch
] }

# API呼び出し
response = call_copilot_api(batch_request)
results.extend(response)

# 次のバッチまで待機
time.sleep(1)

return results

import requests
import time
from typing import Optional, Dict

def call_copilot_api_with_retry(
prompt: str,
max_retries: int = 3
) -> Optional[Dict]:
“""
リトライロジック付きのAPI呼び出し
“""
for attempt in range(max_retries):
try:
response = requests.post(
“https://api.github.com/copilot/completions",
json={“prompt": prompt},
headers={
“Authorization": f"Bearer {API_KEY}",
“Content-Type": “application/json"
},
timeout=30
)

# ステータスコードをチェック
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# レート制限の場合、待機時間を増やして再試行
wait_time = (attempt + 1) * 2
print(f"レート制限。{wait_time}秒待機します…")
time.sleep(wait_time)
elif response.status_code == 401:
print(“認証エラー: APIキーを確認してください")
return None
else:
print(f"エラー: {response.status_code}")

except requests.exceptions.Timeout:
print(f"タイムアウト (試行 {attempt + 1}/{max_retries})")
if attempt < max_retries - 1: time.sleep(2) except requests.exceptions.RequestException as e: print(f"リクエストエラー: {e}") return None print("最大リトライ回数に達しました") return None

# カスタマーサポートボットの実装例
class SupportBot:
def __init__(self, copilot_client):
self.copilot = copilot_client
self.knowledge_base = self.load_knowledge_base()

def answer_question(self, user_question):
“""
ユーザーの質問に対して回答を生成
“""
# ナレッジベースから関連情報を検索
context = self.search_knowledge_base(user_question)

# Copilot APIで回答を生成
prompt = f"""
以下の情報を参考に、ユーザーの質問に丁寧に回答してください。

質問: {user_question}

参考情報: {context}
“""

response = self.copilot.generate_response(prompt)
return response

def search_knowledge_base(self, question):
“""ナレッジベースから関連情報を検索"""
# 検索ロジックを実装
pass

import pandas as pd

class SalesAnalyzer:
def __init__(self, copilot_client):
self.copilot = copilot_client

def analyze_sales_data(self, df):
“""
売上データを分析してレポートを生成
“""
# 基本統計量を計算
summary = df.describe().to_string()

# トレンドを特定
monthly_sales = df.groupby('month’)['sales’].sum()

# Copilot APIで分析レポートを生成
prompt = f"""
以下の売上データを分析し、重要なインサイトを
3つのポイントにまとめてください。

データサマリー:
{summary}

月別売上推移:
{monthly_sales.to_string()}
“""

insights = self.copilot.generate_response(prompt)
return insights

import asyncio
import aiohttp

class AsyncCopilotClient:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = “https://api.github.com/copilot"

async def generate_code_async(self, session, prompt):
“""非同期でコード生成"""
headers = {
“Authorization": f"Bearer {self.api_key}",
“Content-Type": “application/json"
}
payload = {“prompt": prompt}

async with session.post(
f"{self.base_url}/completions",
json=payload,
headers=headers
) as response:
return await response.json()

async def batch_generate(self, prompts):
“""複数のプロンプトを並行処理"""
async with aiohttp.ClientSession() as session:
tasks = [
self.generate_code_async(session, prompt)
for prompt in prompts
] results = await asyncio.gather(*tasks)
return results

# 使用例
async def main():
client = AsyncCopilotClient(API_KEY)
prompts = [
“Pythonでソート関数",
“JavaScriptでバリデーション",
“SQLでJOIN文"
] results = await client.batch_generate(prompts)
print(results)

# 実行
asyncio.run(main())

def stream_response(prompt):
“""
レスポンスをストリーミングで受け取る
“""
response = requests.post(
“https://api.github.com/copilot/completions",
json={“prompt": prompt, “stream": True},
headers={“Authorization": f"Bearer {API_KEY}"},
stream=True
)

for chunk in response.iter_content(chunk_size=1024):
if chunk:
# チャンクを逐次処理
yield chunk.decode('utf-8’)

# 使用例
for part in stream_response(“長いコードを生成"):
print(part, end=", flush=True)