Agent Lambda Code

Author: Taehooon6476

script/agent-cloudformation/bedrock-agent.yaml

@@ -9,7 +9,7 @@ Parameters:
 
   ModelId:
     Type: String
-    Default: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0'
+    Default: 'us.amazon.nova-pro-v1:0'
     Description: 'Foundation model ID for the agent'
 
   DynamoDBTableName:
@@ -55,6 +55,7 @@ Resources:
             Action: sts:AssumeRole
       ManagedPolicyArns:
         - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+        - arn:aws:iam::aws:policy/AmazonBedrockFullAccess
       Policies:
         - PolicyName: !Sub '${AgentName}-DynamoDBReadPolicy'
           PolicyDocument:
@@ -84,53 +85,45 @@ Resources:
           import json
           import os
           import boto3
-          from boto3.dynamodb.conditions import Attr, Contains
-          from decimal import Decimal
+          from boto3.dynamodb.conditions import Attr
 
           def lambda_handler(event, context):
               """
-              Bedrock Agent Action Group을 위한 Lambda 함수
-              사용자 질문에 기반하여 관련 영상을 검색합니다.
+              Bedrock을 활용한 의미 기반 영상 검색
               """
               
               print(f"📥 받은 이벤트: {json.dumps(event, default=str)}")
               
               try:
-                  # Bedrock Agent 이벤트 구조 파싱
                   api_path = event.get('apiPath', '')
                   http_method = event.get('httpMethod', '')
                   request_body = event.get('requestBody', {})
                   
                   print(f"🔍 API Path: {api_path}, Method: {http_method}")
-                  print(f"📦 Request Body: {request_body}")
                   
-                  # DynamoDB 클라이언트 초기화
                   dynamodb = boto3.resource('dynamodb', region_name='us-west-2')
+                  bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
                   
                   if api_path == '/search_classes' and http_method == 'POST':
-                      # requestBody에서 content 추출
                       content = request_body.get('content', {})
                       app_json = content.get('application/json', {})
                       properties = app_json.get('properties', [])
                       
-                      # properties에서 query 파라미터 추출
                       query = ''
                       for prop in properties:
                           if prop.get('name') == 'query':
                               query = prop.get('value', '')
                               break
                       
-                      print(f"🔎 추출된 query: {query}")
-                      result = search_classes(dynamodb, query)
-                      function_name = 'search_classes'
+                      print(f"🔎 사용자 질문: {query}")
+                      result = search_with_bedrock(dynamodb, bedrock, query)
+                      
                   else:
                       result = {
                           'statusCode': 400,
                           'body': json.dumps({'error': 'Unknown endpoint'})
                       }
-                      function_name = 'unknown'
                   
-                  # Bedrock Agent 응답 형식 (AWS 공식 스펙)
                   response = {
                       'messageVersion': '1.0',
                       'response': {
@@ -154,8 +147,7 @@ Resources:
                   import traceback
                   print(f"📋 스택 트레이스: {traceback.format_exc()}")
                   
-                  error_body = {'error': str(e)}
-                  error_response = {
+                  return {
                       'messageVersion': '1.0',
                       'response': {
                           'actionGroup': event.get('actionGroup', ''),
@@ -164,123 +156,128 @@ Resources:
                           'httpStatusCode': 500,
                           'responseBody': {
                               'application/json': {
-                                  'body': error_body
+                                  'body': {'error': str(e)}
                               }
                           }
                       }
                   }
-                  
-                  print(f"📤 에러 응답: {json.dumps(error_response, ensure_ascii=False, default=str)}")
-                  return error_response
 
-          def search_classes(dynamodb, query):
-              """DynamoDB에서 영상 검색 - description 기반 간단 검색"""
-              
-              print(f"🔍 검색 쿼리: {query}")
-              
-              # 검색어를 개별 키워드로 분리
-              search_terms = [term.strip().lower() for term in query.split() if term.strip()] if query else []
-              
-              print(f"🔎 검색어: {search_terms}")
+          def search_with_bedrock(dynamodb, bedrock, query):
+              """Bedrock Nova Pro로 질문 이해 후 DynamoDB 검색"""
               
               table_name = os.environ['DYNAMODB_TABLE_NAME']
               
               try:
+                  # 1. DynamoDB에서 모든 활성 강의 가져오기
                   table = dynamodb.Table(table_name)
+                  response = table.scan(
+                      FilterExpression=Attr('class_flag').ne(10) & (Attr('class_flag').eq(0) | Attr('class_flag').not_exists())
+                  )
+                  
+                  all_courses = response.get('Items', [])
+                  print(f"📊 전체 강의 수: {len(all_courses)}개")
                   
-                  # 검색어가 없으면 빈 결과 반환
-                  if not search_terms:
-                      print("⚠️ 검색어 없음 - 빈 결과 반환")
+                  if not all_courses:
                       return {
                           'statusCode': 200,
                           'body': json.dumps({
                               'courses_found': 0,
                               'courses': [],
-                              'message': '검색어를 입력해주세요.'
+                              'message': '등록된 강의가 없습니다.'
                           }, ensure_ascii=False)
                       }
                   
-                  # 활성 영상만 조회
-                  base_filter = Attr('class_flag').ne(10) & (Attr('class_flag').eq(0) | Attr('class_flag').not_exists())
-                  
-                  # name과 description 필드에서 대소문자 구분 없이 검색
-                  search_conditions = []
-                  for term in search_terms:
-                      term_lower = term.lower()
-                      term_upper = term.upper()
-                      term_title = term.title()
-                      
-                      search_conditions.append(
-                          Contains(Attr('name'), term) |
-                          Contains(Attr('name'), term_lower) |
-                          Contains(Attr('name'), term_upper) |
-                          Contains(Attr('name'), term_title) |
-                          Contains(Attr('description'), term) |
-                          Contains(Attr('description'), term_lower) |
-                          Contains(Attr('description'), term_upper) |
-                          Contains(Attr('description'), term_title)
-                      )
-                  
-                  # OR 조건으로 결합
-                  search_filter = search_conditions[0]
-                  for condition in search_conditions[1:]:
-                      search_filter = search_filter | condition
+                  # 2. 강의 목록을 텍스트로 변환 (최대 50개)
+                  courses_text = "\n\n".join([
+                      f"강의 {i+1}:\n제목: {c.get('name', '')}\n설명: {c.get('description', '')}\n난이도: {c.get('difficulty', 'intermediate')}"
+                      for i, c in enumerate(all_courses[:50])
+                  ])
                   
-                  final_filter = base_filter & search_filter
+                  # 3. Bedrock Nova Pro 프롬프트
+                  prompt = f"""사용자 질문: {query}
+
+          다음은 사용할 수 있는 AWS 강의 목록입니다:
+
+          {courses_text}
+
+          위 강의 중에서 사용자 질문에 가장 적합한 강의를 최대 3개 선택하고, 각 강의 번호만 JSON 배열로 반환하세요.
+          예시: {{"selected": [1, 3, 5]}}
+
+          만약 적합한 강의가 없다면 빈 배열을 반환하세요: {{"selected": []}}
+
+          JSON만 반환하고 다른 설명은 하지 마세요."""
+
+                  # 4. Bedrock Nova Pro 호출
+                  body = json.dumps({
+                      "messages": [
+                          {
+                              "role": "user",
+                              "content": [{"text": prompt}]
+                          }
+                      ],
+                      "inferenceConfig": {
+                          "max_new_tokens": 500,
+                          "temperature": 0.3
+                      }
+                  })
                   
-                  # 스캔 실행
-                  response = table.scan(
-                      FilterExpression=final_filter,
-                      Limit=20
+                  bedrock_response = bedrock.invoke_model(
+                      modelId='us.amazon.nova-pro-v1:0',
+                      body=body
                   )
                   
-                  print(f"📊 스캔 결과: {len(response.get('Items', []))}개 항목")
+                  response_body = json.loads(bedrock_response['body'].read())
+                  bedrock_text = response_body['output']['message']['content'][0]['text']
+                  print(f"🤖 Bedrock 응답: {bedrock_text}")
                   
-                  # 결과 포맷팅 - thumbnail과 URL만 포함
-                  classes = []
-                  for item in response.get('Items', []):
-                      class_info = {
-                          'title': str(item.get('name', '')),
-                          'description': str(item.get('description', ''))[:150] + '...' if len(str(item.get('description', ''))) > 150 else str(item.get('description', '')),
-                          'url': str(item.get('url', '')),
-                          'thumbnail': str(item.get('image', '')),
-                          'author': str(item.get('author', '')),
-                          'difficulty': str(item.get('difficulty', 'intermediate'))
-                      }
-                      classes.append(class_info)
+                  # 5. JSON 추출
+                  selected_indices = json.loads(bedrock_text)['selected']
                   
-                  # 상위 5개만 반환
-                  top_classes = classes[:5]
+                  # 6. 선택된 강의 정보 구성
+                  selected_courses = []
+                  for idx in selected_indices:
+                      if 0 < idx <= len(all_courses):
+                          course = all_courses[idx - 1]
+                          selected_courses.append({
+                              'title': str(course.get('name', '')),
+                              'description': str(course.get('description', ''))[:150] + '...' if len(str(course.get('description', ''))) > 150 else str(course.get('description', '')),
+                              'url': str(course.get('url', '')),
+                              'thumbnail': str(course.get('image', '')),
+                              'author': str(course.get('author', '')),
+                              'difficulty': str(course.get('difficulty', 'intermediate'))
+                          })
                   
-                  message = f"'{' '.join(search_terms)}' 관련 강의 {len(top_classes)}개를 찾았습니다." if top_classes else f"'{' '.join(search_terms)}' 관련 강의를 찾지 못했습니다."
+                  message = f"'{query}' 관련 강의 {len(selected_courses)}개를 찾았습니다." if selected_courses else f"'{query}' 관련 강의를 찾지 못했습니다."
                   
                   result_data = {
-                      'courses_found': len(top_classes),
-                      'courses': top_classes,
+                      'courses_found': len(selected_courses),
+                      'courses': selected_courses,
                       'message': message,
                       'traces': [
-                          {'type': 'preprocessing', 'content': f"🔍 '{' '.join(search_terms)}' 검색 시작", 'timestamp': ''},
-                          {'type': 'function_call', 'content': f'⚡ DynamoDB에서 {len(classes)}개 항목 발견', 'timestamp': ''},
-                          {'type': 'observation', 'content': f'✅ 상위 {len(top_classes)}개 강의 선택 완료', 'timestamp': ''}
+                          {'type': 'preprocessing', 'content': f"🔍 '{query}' 검색 시작", 'timestamp': ''},
+                          {'type': 'function_call', 'content': f'⚡ Bedrock Nova Pro로 {len(all_courses)}개 강의 분석', 'timestamp': ''},
+                          {'type': 'observation', 'content': f'✅ {len(selected_courses)}개 강의 선택 완료', 'timestamp': ''}
                       ]
                   }
                   
-                  print(f"✅ 검색 완료: {len(top_classes)}개 영상 발견")
-                  print(f"📊 결과 데이터: {json.dumps(result_data, ensure_ascii=False)}")
+                  print(f"✅ 검색 완료: {len(selected_courses)}개 강의 발견")
                   
                   return {
                       'statusCode': 200,
                       'body': json.dumps(result_data, ensure_ascii=False)
                   }
                   
               except Exception as e:
-                  print(f"❌ 테이블 접근 오류: {str(e)}")
+                  print(f"❌ 검색 오류: {str(e)}")
+                  import traceback
+                  print(traceback.format_exc())
                   return {
                       'statusCode': 500,
-                      'body': json.dumps({'error': f'Database error: {str(e)}'})
+                      'body': json.dumps({'error': f'Search error: {str(e)}'})
                   }
 
 
+
   # Lambda Permission for Bedrock Agent
   LambdaInvokePermission:
     Type: AWS::Lambda::Permission