AgentCore Gateway にツールを束ねて Managed Harness から使ってみた

agentcore-gateway-kit/
├── bin/
│   └── app.ts                     # CDK エントリーポイント
├── lib/
│   ├── knowledge-base-stack.ts    # Stack 1: KB + S3 Vectors
│   └── rag-gateway-stack.ts       # Stack 2: Gateway + Lambda + Runtime
├── lambda/
│   └── kb-retrieve/
│       └── index.py               # KB Retrieve Lambda
├── mcp-server/
│   ├── server.py                  # FastMCP Web Tools
│   ├── requirements.txt
│   └── Dockerfile
├── sample-data/
│   └── sample.txt
├── cdk.json
├── package.json
└── tsconfig.json

const vectorBucket = new s3vectors.CfnVectorBucket(this, 'VectorBucket', {
  vectorBucketName,
});

const vectorIndex = new s3vectors.CfnIndex(this, 'VectorIndex', {
  vectorBucketName,
  indexName: 'rag-gateway-index',
  dimension: VECTOR_DIMENSION,
  distanceMetric: 'cosine',
  dataType: 'float32',
});
vectorIndex.addDependency(vectorBucket);

const knowledgeBase = new bedrock.CfnKnowledgeBase(this, 'KnowledgeBase', {
  name: 'RagGatewayKnowledgeBase',
  roleArn: kbRole.roleArn,
  knowledgeBaseConfiguration: {
    type: 'VECTOR',
    vectorKnowledgeBaseConfiguration: {
      embeddingModelArn: `arn:aws:bedrock:${cdk.Aws.REGION}::foundation-model/${EMBEDDING_MODEL_ID}`,
    },
  },
  storageConfiguration: {
    type: 'S3_VECTORS',
    s3VectorsConfiguration: {
      vectorBucketArn: vectorBucket.attrVectorBucketArn,
      indexName: vectorIndex.indexName!,
    },
  },
});

const gateway = new agentcore.Gateway(this, 'RagGateway', {
  gatewayName: 'rag-gateway-kit',
  description: 'RAG Gateway Kit: KB Retrieve + Web Fetch + AWS Knowledge',
  authorizerConfiguration: agentcore.GatewayAuthorizer.usingAwsIam(),
});

gateway.addLambdaTarget('KBRetrieveTarget', {
  gatewayTargetName: 'kb-retrieve',
  lambdaFunction: kbRetrieveFn,
  toolSchema: agentcore.ToolSchema.fromInline([
    {
      name: 'retrieve_documents',
      description: 'ナレッジベースからドキュメントを検索します。',
      inputSchema: {
        type: agentcore.SchemaDefinitionType.OBJECT,
        properties: {
          query: { type: agentcore.SchemaDefinitionType.STRING, description: '検索クエリ' },
          maxResults: { type: agentcore.SchemaDefinitionType.INTEGER, description: '最大取得件数' },
        },
        required: ['query'],
      },
    },
  ]),
});

def handler(event, context):
    query = event.get('query', '')
    kb_id = event.get('knowledgeBaseId', KNOWLEDGE_BASE_ID)
    max_results = min(event.get('maxResults', 5), 100)

    response = client.retrieve(
        knowledgeBaseId=kb_id,
        retrievalQuery={'text': query},
        retrievalConfiguration={
            'vectorSearchConfiguration': { 'numberOfResults': max_results }
        },
    )

    results = []
    for r in response.get('retrievalResults', []):
        results.append({
            'content': r['content'].get('text', ''),
            'score': r.get('score'),
            'location': r.get('location', {}),
        })

    return { 'results': results, 'count': len(results) }

mcp = FastMCP("web-tools", host="0.0.0.0", stateless_http=True)

@mcp.tool()
def fetch_webpage(url: str, max_length: int = 5000) -> str:
    """Fetch a web page and return its text content."""
    response = httpx.get(url, follow_redirects=True, timeout=30, headers={
        'User-Agent': 'AgentCore-WebTools/1.0',
    })
    response.raise_for_status()

    html = response.text
    text = re.sub(r'<script[^>]*>.*?</script>', '', html, flags=re.DOTALL)
    text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL)
    text = re.sub(r'<[^>]+>', ' ', text)
    text = re.sub(r'\s+', ' ', text).strip()

    return text[:max_length]

const runtimeEndpointUrl = cdk.Fn.sub(
  'https://bedrock-agentcore.${AWS::Region}.amazonaws.com/runtimes/arn%3Aaws%3Abedrock-agentcore%3A${AWS::Region}%3A${AWS::AccountId}%3Aruntime%2F${RuntimeId}/invocations',
  { RuntimeId: webToolsRuntime.agentRuntimeId },
);

const webToolsTarget = new bedrockagentcore.CfnGatewayTarget(this, 'WebToolsTarget', {
  gatewayIdentifier: gateway.gatewayId,
  name: 'web-tools',
  targetConfiguration: {
    mcp: {
      mcpServer: { endpoint: runtimeEndpointUrl },
    },
  },
  credentialProviderConfigurations: [{
    credentialProviderType: 'GATEWAY_IAM_ROLE',
    credentialProvider: {
      iamCredentialProvider: { service: 'bedrock-agentcore' },
    },
  }],
});

webToolsTarget.addDependency(
  webToolsRuntime.node.defaultChild as cdk.CfnResource,
);
const gatewayDefaultPolicy = gateway.role.node.findChild('DefaultPolicy').node.defaultChild as cdk.CfnResource;
webToolsTarget.addDependency(gatewayDefaultPolicy);

new bedrockagentcore.CfnGatewayTarget(this, 'AWSKnowledgeTarget', {
  gatewayIdentifier: gateway.gatewayId,
  name: 'aws-knowledge',
  targetConfiguration: {
    mcp: {
      mcpServer: { endpoint: 'https://knowledge-mcp.global.api.aws' },
    },
  },
});

gateway.addLambdaTarget('MyNewTarget', {
  gatewayTargetName: 'my-tool',
  lambdaFunction: myFunction,
  toolSchema: agentcore.ToolSchema.fromInline([{
    name: 'my_tool',
    description: 'ツールの説明',
    inputSchema: {
      type: agentcore.SchemaDefinitionType.OBJECT,
      properties: { /* ... */ },
    },
  }]),
});

new bedrockagentcore.CfnGatewayTarget(this, 'MyMcpTarget', {
  gatewayIdentifier: gateway.gatewayId,
  name: 'my-mcp-server',
  targetConfiguration: {
    mcp: {
      mcpServer: {
        endpoint: 'https://your-mcp-server.example.com',
      },
    },
  },
  credentialProviderConfigurations: [{
    credentialProviderType: 'GATEWAY_IAM_ROLE',
    credentialProvider: {
      iamCredentialProvider: {
        service: 'bedrock-agentcore',
      },
    },
  }],
});

npm install
npx cdk deploy --all

aws bedrock-agent start-ingestion-job \
  --knowledge-base-id <KnowledgeBaseId> \
  --data-source-id <DataSourceId>

aws s3 cp my-document.txt s3://<DataSourceBucketName>/

aws bedrock-agent start-ingestion-job \
  --knowledge-base-id <KnowledgeBaseId> \
  --data-source-id <DataSourceId>