1
# lambda_function.py
2
# Alexa × AWS Bedrock Claudeトーク
3

4
import json
5
import boto3
6
import logging
7
import time
8
from datetime import datetime
9

10
# ログ設定
11
logger = logging.getLogger()
12
logger.setLevel(logging.INFO)
13

14
# Bedrock クライアント
15
bedrock = boto3.client('bedrock-runtime', region_name='ap-northeast-1')
16

17
# CloudWatch クライアント（コストチェック用）
18
cloudwatch = boto3.client('cloudwatch')
19

20
# モデル設定
21
MODEL_ID = "jp.anthropic.claude-sonnet-4-5-20250929-v1:0"
22

23
# コスト設定
24
# 月間利用上限（USD）- この金額に達するとスキルを一時停止
25
COST_LIMIT_USD = 5.00
26

27
# AWS Bedrock JP Regional 料金（1トークンあたりの単価）
28
INPUT_TOKEN_PRICE = 0.0033 / 1000   # $0.0033 / 1K tokens
29
OUTPUT_TOKEN_PRICE = 0.0165 / 1000  # $0.0165 / 1K tokens
30

31
# システムプロンプト
32
SYSTEM_PROMPT = """あなたはAlexaの音声アシスタントです。
33

34
【回答の長さルール】
35
- 雑談・挨拶: 1-2文（50文字程度）
36
- 質問への回答: 3-5文（150文字程度）
37
- 説明・解説を求められた場合: 5-10文（300文字程度）
38
- 「詳しく」「もっと教えて」と言われたら: 長めに回答
39

40
【基本ルール】
41
- 音声で聞きやすいよう、箇条書きは避ける
42
- 「〜ですね」「〜ですよ」など話し言葉で
43
- 長くなりそうなら「続きを聞きますか？」と確認
44
"""
45

46
def lambda_handler(event, context):
47
    """Lambda メインハンドラー"""
48
    logger.info(f"Received event: {json.dumps(event, ensure_ascii=False)}")
49

50
    request_type = event['request']['type']
51

52
    # スキル起動時（「アレクサ、クロードトークを開いて」）
53
    if request_type == 'LaunchRequest':
54
        return handle_launch_request(event)
55
    # ユーザーが何か話しかけた時
56
    elif request_type == 'IntentRequest':
57
        return handle_intent_request(event)
58
    # セッション終了時（タイムアウトやエラー）
59
    elif request_type == 'SessionEndedRequest':
60
        return handle_session_ended_request(event)
61
    else:
62
        return build_response("すみません、よく分かりませんでした。")
63

64

65
def handle_launch_request(event):
66
    """スキル起動時の処理"""
67
    # コストチェック（起動時のみ）
68
    cost_check = check_monthly_cost()
69

70
    if cost_check['is_exceeded']:
71
        return build_response(
72
            f"申し訳ありません。今月の利用上限{COST_LIMIT_USD}ドルに達したため、クロードトークは一時停止中です。現在の利用額は{cost_check['current_cost']:.2f}ドルです。来月またお話しましょう。",
73
            should_end_session=True
74
        )
75

76
    speech = "クロードトークを起動しました。何でも話しかけてください。"
77
    return build_response(speech, should_end_session=False)
78

79

80
def handle_intent_request(event):
81
    """インテント処理"""
82
    intent_name = event['request']['intent']['name']
83

84
    # 会話インテント（ユーザーの発話を処理）
85
    if intent_name == 'ConversationIntent':
86
        return handle_conversation_intent(event)
87
    # ヘルプ（「ヘルプ」「使い方を教えて」）
88
    elif intent_name == 'AMAZON.HelpIntent':
89
        return handle_help_intent()
90
    # 終了（「終了」「ストップ」「キャンセル」）
91
    elif intent_name in ['AMAZON.CancelIntent', 'AMAZON.StopIntent']:
92
        return handle_stop_intent()
93
    # 聞き取れなかった時
94
    elif intent_name == 'AMAZON.FallbackIntent':
95
        return handle_fallback_intent()
96
    else:
97
        return build_response("すみません、よく分かりませんでした。", should_end_session=False)
98

99

100
def handle_conversation_intent(event):
101
    """会話インテントの処理"""
102
    try:
103
        # ユーザー入力を取得
104
        slots = event['request']['intent'].get('slots', {})
105
        user_input = slots.get('UserInput', {}).get('value', '')
106

107
        if not user_input:
108
            return build_response(
109
                "すみません、聞き取れませんでした。もう一度話しかけてください。",
110
                should_end_session=False
111
            )
112

113
        logger.info(f"User input: {user_input}")
114

115
        # セッション属性から会話履歴を取得（初回は空）
116
        session_attributes = event.get('session', {}).get('attributes', {}) or {}
117
        conversation_history = session_attributes.get('history', [])
118

119
        # 会話履歴にユーザー入力を追加
120
        conversation_history.append({
121
            "role": "user",
122
            "content": user_input
123
        })
124

125
        # Bedrockで応答を生成
126
        start_time = time.time()
127
        ai_response = get_bedrock_response(conversation_history)
128
        elapsed_time = time.time() - start_time
129
        logger.info(f"Bedrock response time: {elapsed_time:.2f}s")
130

131
        # 会話履歴にAI応答を追加
132
        conversation_history.append({
133
            "role": "assistant",
134
            "content": ai_response
135
        })
136

137
        # 履歴が長くなりすぎたら古いものを削除（直近30往復まで）
138
        if len(conversation_history) > 60:
139
            conversation_history = conversation_history[-60:]
140

141
        # セッション属性を更新
142
        session_attributes['history'] = conversation_history
143

144
        return build_response(
145
            ai_response,
146
            should_end_session=False,
147
            session_attributes=session_attributes
148
        )
149

150
    except Exception as e:
151
        logger.error(f"Error in conversation: {str(e)}", exc_info=True)
152
        return build_response(
153
            "すみません、エラーが発生しました。もう一度話しかけてください。",
154
            should_end_session=False
155
        )
156

157

158
def get_bedrock_response(conversation_history):
159
    """Bedrockを呼び出してAI応答を取得"""
160
    try:
161
        response = bedrock.invoke_model(
162
            modelId=MODEL_ID,
163
            body=json.dumps({
164
                "anthropic_version": "bedrock-2023-05-31",
165
                "max_tokens": 500,
166
                "system": SYSTEM_PROMPT,
167
                "messages": conversation_history
168
            }),
169
            contentType='application/json'
170
        )
171

172
        # レスポンスからAIの応答テキストを取得
173
        response_body = json.loads(response['body'].read())
174
        ai_response = response_body['content'][0]['text']
175

176
        logger.info(f"AI response: {ai_response}")
177
        return ai_response
178

179
    except Exception as e:
180
        logger.error(f"Bedrock error: {str(e)}", exc_info=True)
181
        raise
182

183

184
def handle_help_intent():
185
    """ヘルプインテントの処理"""
186
    speech = "クロードトークでは、何でも話しかけることができます。質問したり、雑談したり、自由に会話を楽しんでください。"
187
    return build_response(speech, should_end_session=False)
188

189

190
def handle_stop_intent():
191
    """停止インテントの処理"""
192
    speech = "クロードトークを終了します。またお話ししましょう。"
193
    return build_response(speech, should_end_session=True)
194

195

196
def handle_fallback_intent():
197
    """フォールバックインテントの処理"""
198
    speech = "すみません、うまく聞き取れませんでした。もう一度話しかけてください。"
199
    return build_response(speech, should_end_session=False)
200

201

202
def handle_session_ended_request(event):
203
    """セッション終了時の処理"""
204
    logger.info("Session ended")
205
    return build_response("", should_end_session=True)
206

207

208
def calculate_cost(input_tokens, output_tokens):
209
    """トークン数からコスト（USD）を計算"""
210
    input_cost = input_tokens * INPUT_TOKEN_PRICE
211
    output_cost = output_tokens * OUTPUT_TOKEN_PRICE
212
    return input_cost + output_cost
213

214

215
def check_monthly_cost():
216
    """CloudWatchメトリクスから月間コストを計算"""
217
    logger.info(f"Starting cost check. Limit: ${COST_LIMIT_USD}")
218

219
    try:
220
        # 月初から現在までの期間を設定
221
        now = datetime.now()
222
        start_of_month = datetime(now.year, now.month, 1)
223

224
        # トークン数を取得
225
        total_input_tokens = get_metric_sum(MODEL_ID, 'InputTokenCount', start_of_month, now)
226
        total_output_tokens = get_metric_sum(MODEL_ID, 'OutputTokenCount', start_of_month, now)
227

228
        # コスト計算
229
        current_cost = calculate_cost(int(total_input_tokens), int(total_output_tokens))
230
        is_exceeded = current_cost >= COST_LIMIT_USD
231

232
        logger.info(f"Monthly cost check: ${current_cost:.4f} / ${COST_LIMIT_USD} (Input: {int(total_input_tokens)}, Output: {int(total_output_tokens)})")
233

234
        if is_exceeded:
235
            logger.warning(f"Cost limit exceeded! ${current_cost:.2f} >= ${COST_LIMIT_USD}")
236

237
        return {
238
            'is_exceeded': is_exceeded,
239
            'current_cost': current_cost,
240
            'limit': COST_LIMIT_USD
241
        }
242

243
    except Exception as e:
244
        logger.error(f"Error checking cost: {e}", exc_info=True)
245
        # エラー時は安全のため続行を許可
246
        return {'is_exceeded': False, 'current_cost': 0, 'limit': COST_LIMIT_USD}
247

248

249
def get_metric_sum(model_id, metric_name, start_time, end_time):
250
    """CloudWatchメトリクスの合計値を取得"""
251
    try:
252
        response = cloudwatch.get_metric_data(
253
            MetricDataQueries=[
254
                {
255
                    'Id': 'token_count',
256
                    'MetricStat': {
257
                        'Metric': {
258
                            'Namespace': 'AWS/Bedrock',
259
                            'MetricName': metric_name,
260
                            'Dimensions': [
261
                                {'Name': 'ModelId', 'Value': model_id}
262
                            ]
263
                        },
264
                        'Period': 2592000,  # 30日
265
                        'Stat': 'Sum'
266
                    }
267
                }
268
            ],
269
            StartTime=start_time,
270
            EndTime=end_time
271
        )
272

273
        # 取得した値を合計して返す（データがなければ0）
274
        values = response['MetricDataResults'][0].get('Values', [])
275
        return sum(values) if values else 0
276

277
    except Exception as e:
278
        logger.warning(f"Failed to get metric {model_id}/{metric_name}: {e}")
279
        return 0
280

281

282
def build_response(speech, should_end_session=True, session_attributes=None):
283
    """Alexa応答を構築"""
284
    response = {
285
        "version": "1.0",
286
        "response": {
287
            "outputSpeech": {
288
                "type": "PlainText",
289
                "text": speech
290
            },
291
            "shouldEndSession": should_end_session
292
        }
293
    }
294

295
    if session_attributes:
296
        response["sessionAttributes"] = session_attributes
297

298
    # 会話を続ける場合はリプロンプトを追加（無言時にユーザーの発話を促す音声）
299
    if not should_end_session and speech:
300
        response["response"]["reprompt"] = {
301
            "outputSpeech": {
302
                "type": "PlainText",
303
                "text": "何か話しかけてください。"
304
            }
305
        }
306

307
    return response

1
{
2
    "interactionModel": {
3
        "languageModel": {
4
            "invocationName": "クロードトーク",
5
            "intents": [
6
                {
7
                    "name": "AMAZON.CancelIntent",
8
                    "samples": []
9
                },
10
                {
11
                    "name": "AMAZON.HelpIntent",
12
                    "samples": []
13
                },
14
                {
15
                    "name": "AMAZON.StopIntent",
16
                    "samples": []
17
                },
18
                {
19
                    "name": "AMAZON.NavigateHomeIntent",
20
                    "samples": []
21
                },
22
                {
23
                    "name": "ConversationIntent",
24
                    "slots": [
25
                        {
26
                            "name": "UserInput",
27
                            "type": "AMAZON.Language"
28
                        }
29
                    ],
30
                    "samples": [
31
                        "{UserInput}"
32
                    ]
33
                }
34
            ],
35
            "types": []
36
        }
37
    }
38
}