AI/ML Services

import { bedrock } from "@pulumi/aws";

// Create a custom model with fine-tuning
const customModel = new bedrock.CustomModel("custom-llm", {
    customModelName: "my-custom-model",
    jobName: "training-job-001",
    baseModelIdentifier: "amazon.titan-text-express-v1",
    roleArn: bedrockRole.arn,
    trainingDataConfig: {
        s3Uri: `s3://${trainingBucket.id}/training-data/`,
    },
    outputDataConfig: {
        s3Uri: `s3://${outputBucket.id}/output/`,
    },
    hyperparameters: {
        epochCount: "3",
        batchSize: "1",
    },
});

// Create a knowledge base for RAG
const knowledgeBase = new bedrock.KnowledgeBase("docs", {
    name: "documentation-kb",
    roleArn: kbRole.arn,
    knowledgeBaseConfiguration: {
        type: "VECTOR",
        vectorKnowledgeBaseConfiguration: {
            embeddingModelArn: "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v1",
        },
    },
    storageConfiguration: {
        type: "OPENSEARCH_SERVERLESS",
        opensearchServerlessConfiguration: {
            collectionArn: opensearchCollection.arn,
            vectorIndexName: "bedrock-knowledge-base-index",
            fieldMapping: {
                vectorField: "vector",
                textField: "text",
                metadataField: "metadata",
            },
        },
    },
});

// Create an agent with action groups
const agent = new bedrock.Agent("assistant", {
    agentName: "customer-service-agent",
    foundationModel: "anthropic.claude-3-sonnet-20240229-v1:0",
    instruction: "You are a helpful customer service assistant.",
    agentResourceRoleArn: agentRole.arn,
});

import { sagemaker } from "@pulumi/aws";

// Create a SageMaker domain for Studio
const domain = new sagemaker.Domain("ml-platform", {
    domainName: "ml-development",
    authMode: "IAM",
    defaultUserSettings: {
        executionRole: sagemakerRole.arn,
    },
    vpcId: vpc.id,
    subnetIds: subnetIds,
});

// Create a user profile
const userProfile = new sagemaker.UserProfile("data-scientist", {
    domainId: domain.id,
    userProfileName: "ds-user",
    userSettings: {
        executionRole: sagemakerRole.arn,
    },
});

// Create a model
const model = new sagemaker.Model("text-classifier", {
    executionRoleArn: sagemakerRole.arn,
    primaryContainer: {
        image: `${accountId}.dkr.ecr.${region}.amazonaws.com/my-model:latest`,
        modelDataUrl: `s3://${modelBucket.id}/model.tar.gz`,
    },
});

// Create an endpoint configuration
const endpointConfig = new sagemaker.EndpointConfiguration("production", {
    productionVariants: [{
        variantName: "variant-1",
        modelName: model.name,
        instanceType: "ml.m5.xlarge",
        initialInstanceCount: 2,
    }],
});

// Deploy the endpoint
const endpoint = new sagemaker.Endpoint("api", {
    endpointConfigName: endpointConfig.name,
});

// Create a training job
const trainingJob = new sagemaker.TrainingJob("model-training", {
    roleArn: sagemakerRole.arn,
    algorithmSpecification: {
        trainingImage: `${accountId}.dkr.ecr.${region}.amazonaws.com/training:latest`,
        trainingInputMode: "File",
    },
    inputDataConfig: [{
        channelName: "training",
        dataSource: {
            s3DataSource: {
                s3DataType: "S3Prefix",
                s3Uri: `s3://${trainingBucket.id}/data/`,
            },
        },
    }],
    outputDataConfig: {
        s3OutputPath: `s3://${outputBucket.id}/output/`,
    },
    resourceConfig: {
        instanceType: "ml.p3.2xlarge",
        instanceCount: 1,
        volumeSizeInGb: 50,
    },
    stoppingCondition: {
        maxRuntimeInSeconds: 86400,
    },
});

// Feature Store for ML features
const featureGroup = new sagemaker.FeatureGroup("customer-features", {
    featureGroupName: "customer-features",
    recordIdentifierFeatureName: "customer_id",
    eventTimeFeatureName: "event_time",
    roleArn: sagemakerRole.arn,
    featureDefinitions: [
        { featureName: "customer_id", featureType: "String" },
        { featureName: "age", featureType: "Integral" },
        { featureName: "total_purchases", featureType: "Fractional" },
        { featureName: "event_time", featureType: "String" },
    ],
    onlineStoreConfig: {
        enableOnlineStore: true,
    },
    offlineStoreConfig: {
        s3StorageConfig: {
            s3Uri: `s3://${featuresBucket.id}/`,
        },
    },
});

import { comprehend } from "@pulumi/aws";

// Create a document classifier
const classifier = new comprehend.DocumentClassifier("support-tickets", {
    name: "ticket-classifier",
    dataAccessRoleArn: comprehendRole.arn,
    languageCode: "en",
    inputDataConfig: {
        s3Uri: `s3://${trainingBucket.id}/training-data/`,
    },
    outputDataConfig: {
        s3Uri: `s3://${outputBucket.id}/output/`,
    },
});

// Create an entity recognizer for custom entities
const entityRecognizer = new comprehend.EntityRecognizer("product-names", {
    name: "product-recognizer",
    dataAccessRoleArn: comprehendRole.arn,
    languageCode: "en",
    inputDataConfig: {
        entityTypes: [
            { type: "PRODUCT" },
            { type: "FEATURE" },
        ],
        documents: {
            s3Uri: `s3://${trainingBucket.id}/documents/`,
        },
        annotations: {
            s3Uri: `s3://${trainingBucket.id}/annotations/`,
        },
    },
});

import { rekognition } from "@pulumi/aws";

// Create a collection for face search
const faceCollection = new rekognition.Collection("employees", {
    collectionId: "employee-faces",
});

// Create a custom labels project
const project = new rekognition.Project("product-detection", {
    name: "product-detector",
});

// Create a stream processor for real-time video analysis
const streamProcessor = new rekognition.StreamProcessor("security-camera", {
    name: "entrance-monitor",
    roleArn: rekognitionRole.arn,
    kinesisVideoStream: {
        arn: kinesisStream.arn,
    },
    kinesisDataStream: {
        arn: outputStream.arn,
    },
    settings: {
        faceSearch: {
            collectionId: faceCollection.collectionId,
            faceMatchThreshold: 95,
        },
    },
});

import { polly } from "@pulumi/aws";

// Create a lexicon for custom pronunciation
const lexicon = new polly.Lexicon("company-terms", {
    name: "company-terminology",
    content: `<?xml version="1.0" encoding="UTF-8"?>
<lexicon version="1.0" xmlns="http://www.w3.org/2005/01/pronunciation-lexicon">
  <lexeme>
    <grapheme>AWS</grapheme>
    <alias>Amazon Web Services</alias>
  </lexeme>
</lexicon>`,
});

// Application code example to synthesize speech:
// const polly = new AWS.Polly();
// polly.synthesizeSpeech({
//   Text: "Hello from AWS Polly",
//   OutputFormat: "mp3",
//   VoiceId: "Joanna",
//   Engine: "neural"
// });

import { kendra } from "@pulumi/aws";

// Create a Kendra index
const index = new kendra.Index("docs", {
    name: "documentation-search",
    roleArn: kendraRole.arn,
    edition: "ENTERPRISE_EDITION",
});

// Add a data source
const dataSource = new kendra.DataSource("s3-docs", {
    indexId: index.id,
    name: "s3-documentation",
    type: "S3",
    configuration: JSON.stringify({
        S3Configuration: {
            BucketName: docsBucket.id,
        },
    }),
    roleArn: kendraRole.arn,
});

// Create an experience (search application)
const experience = new kendra.Experience("portal", {
    indexId: index.id,
    name: "search-portal",
    roleArn: kendraRole.arn,
    configuration: {
        contentSourceConfiguration: {
            dataSourceIds: [dataSource.id],
        },
    },
});

import { lex } from "@pulumi/aws";

// Create a bot for customer service
const bot = new lex.V2modelsBot("support-bot", {
    name: "customer-support",
    roleArn: lexRole.arn,
    dataPrivacy: {
        childDirected: false,
    },
    idleSessionTtlInSeconds: 300,
});

// Create a bot locale
const locale = new lex.V2modelsBotLocale("en", {
    botId: bot.id,
    botVersion: "DRAFT",
    localeId: "en_US",
    nluIntentConfidenceThreshold: 0.7,
});

// Create an intent
const intent = new lex.V2modelsIntent("check-order", {
    botId: bot.id,
    botVersion: "DRAFT",
    localeId: locale.localeId,
    name: "CheckOrderStatus",
    sampleUtterances: [
        { utterance: "Where is my order" },
        { utterance: "Track my order" },
        { utterance: "Order status" },
    ],
});

// Create a slot type for custom values
const slotType = new lex.V2modelsSlotType("order-id", {
    botId: bot.id,
    botVersion: "DRAFT",
    localeId: locale.localeId,
    name: "OrderId",
    valueSelectionSetting: {
        resolutionStrategy: "ORIGINAL_VALUE",
    },
});