{
  "name": "next-prisma-hello",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint"
  },
  "dependencies": {
    "@aws-sdk/client-bedrock-runtime": "^3.490.0",
    "@aws-sdk/client-s3": "^3.525.0",
    "@aws-sdk/credential-provider-node": "^3.525.0",
    "@aws-sdk/credential-providers": "^3.525.0",
    "@aws-sdk/s3-request-presigner": "^3.525.0",
    "@opensearch-project/opensearch": "^2.5.0",
    "@prisma/client": "^5.8.0",
    "ai": "^2.2.33",
    "aws-sdk": "^2.1569.0",
    "i": "^0.3.7",
    "langchain": "^0.1.25",
    "next": "14.0.4",
    "npm": "^10.5.0",
    "package.json": "^2.0.1",
    "react": "^18",
    "react-dom": "^18"
  },
  "devDependencies": {
    "@types/node": "^20",
    "@types/react": "^18",
    "@types/react-dom": "^18",
    "autoprefixer": "^10.0.1",
    "eslint": "^8",
    "eslint-config-next": "14.0.4",
    "postcss": "^8",
    "prisma": "^5.8.0",
    "tailwindcss": "^3.3.0",
    "typescript": "^5"
  }
}

/*
 * Copyright OpenSearch Contributors
 * SPDX-License-Identifier: Apache-2.0
 *
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
 */

'use strict'
const Connection = require('../Connection')
const Transport = require('../Transport')
const aws4 = require('aws4')
const AwsSigv4SignerError = require('./errors')
const crypto = require('crypto')
const { toMs } = Transport.internals

const getAwsSDKCredentialsProvider = async () => {
  // First try V3
  try {
    const awsV3 = await import('@aws-sdk/credential-provider-node')
    if (typeof awsV3.defaultProvider === 'function') {
      return awsV3.defaultProvider()
    }
  } catch (err) {
    // Ignore
  }
  // try {
  //   const awsV2 = await import('aws-sdk');
  //   if (awsV2.default && typeof awsV2.default.config.getCredentials === 'function') {
  //     return () =>
  //       new Promise((resolve, reject) => {
  //         awsV2.default.config.getCredentials((err, credentials) => {
  //           if (err) {
  //             reject(err);
  //           } else {
  //             resolve(credentials);
  //           }
  //         });
  //       });
  //   }
  // } catch (err) {
  //   // Ignore
  // }

  throw new AwsSigv4SignerError(
    'Unable to find a valid AWS SDK, please provide a valid getCredentials function to AwsSigv4Signer options.'
  )
}

const awsDefaultCredentialsProvider = () =>
  new Promise((resolve, reject) => {
    getAwsSDKCredentialsProvider()
      .then(provider => {
        provider().then(resolve).catch(reject)
      })
      .catch(err => {
        reject(err)
      })
  })

function AwsSigv4Signer(opts = {}) {
  const credentialsState = {
    credentials: null
  }
  if (!opts.region) {
    throw new AwsSigv4SignerError('Region cannot be empty')
  }
  if (!opts.service) {
    opts.service = 'es'
  }
  if (typeof opts.getCredentials !== 'function') {
    opts.getCredentials = awsDefaultCredentialsProvider
  }

  function buildSignedRequestObject(request = {}) {
    request.service = opts.service
    request.region = opts.region
    request.headers = request.headers || {}
    request.headers['host'] = request.hostname
    const signed = aws4.sign(request, credentialsState.credentials)
    signed.headers['x-amz-content-sha256'] = crypto
      .createHash('sha256')
      .update(request.body || '', 'utf8')
      .digest('hex')
    return signed
  }

  class AwsSigv4SignerConnection extends Connection {
    buildRequestObject(params) {
      const request = super.buildRequestObject(params)
      return buildSignedRequestObject(request)
    }
  }

  class AwsSigv4SignerTransport extends Transport {
    request(params, options = {}, callback = undefined) {
      // options is optional so if options is a function, it's the callback.
      if (typeof options === 'function') {
        callback = options
        options = {}
      }

      const currentCredentials = credentialsState.credentials
      /**
       * For AWS SDK V3
       * Make sure token will expire no earlier than `expiryBufferMs` milliseconds in the future.
       */
      const expiryBufferMs = toMs(options.requestTimeout || this.requestTimeout)

      let expired = false
      if (!currentCredentials) {
        // Credentials haven't been acquired yet.
        expired = true
      }
      // AWS SDK V2, needsRefresh should be available.
      else if (typeof currentCredentials.needsRefresh === 'function') {
        expired = currentCredentials.needsRefresh()
      }
      // AWS SDK V2, alternative to needsRefresh.
      else if (currentCredentials.expired === true) {
        expired = true
      }
      // AWS SDK V2, alternative to needsRefresh and expired.
      else if (
        currentCredentials.expireTime &&
        currentCredentials.expireTime < new Date()
      ) {
        expired = true
      }
      // AWS SDK V3, Credentials.expiration is a Date object
      else if (
        currentCredentials.expiration &&
        currentCredentials.expiration.getTime() - Date.now() < expiryBufferMs
      ) {
        expired = true
      }

      if (!expired) {
        if (typeof callback === 'undefined') {
          return super.request(params, options)
        }
        super.request(params, options, callback)
        return
      }

      // In AWS SDK V2 Credentials.refreshPromise should be available.
      if (
        currentCredentials &&
        typeof currentCredentials.refreshPromise === 'function'
      ) {
        if (typeof callback === 'undefined') {
          return currentCredentials.refreshPromise().then(() => {
            return super.request(params, options)
          })
        } else {
          currentCredentials
            .refreshPromise()
            .then(() => {
              super.request(params, options, callback)
            })
            .catch(callback)
          return
        }
      }

      // For AWS SDK V3 or when the client has not acquired credentials yet.
      if (typeof callback === 'undefined') {
        return opts.getCredentials().then(credentials => {
          credentialsState.credentials = credentials
          return super.request(params, options)
        })
      } else {
        opts
          .getCredentials()
          .then(credentials => {
            credentialsState.credentials = credentials
            super.request(params, options, callback)
          })
          .catch(callback)
      }
    }
  }

  return {
    Transport: AwsSigv4SignerTransport,
    Connection: AwsSigv4SignerConnection,
    buildSignedRequestObject
  }
}
module.exports = AwsSigv4Signer

'use client'

import { indexAoss, queryAoss } from './action'

const IndexPage = () => {
  return (
    <div className="flex flex-col w-full max-w-md py-24 mx-auto stretch">
      <div>
        <form
          onSubmit={event => {
            event.preventDefault()
          }}
        >
          <textarea
            className="bg-gray-200 w-full p-5"
            rows={15}
            placeholder="document ..."
          ></textarea>
          <button
            className="px-10 py-3 rounded-sm bg-orange-400"
            onClick={async event => {
              event.preventDefault()
              const result = await indexAoss({ doc: '', title: '' })
            }}
          >
            Index
          </button>
        </form>
        <div className="mt-10">
          <form
            onSubmit={event => {
              event.preventDefault()
            }}
          >
            <input
              className="w-full px-5 py-3 bg-gray-200"
              placeholder="query ..."
              type="text"
              id="query"
              name="query"
            ></input>
            <button
              className="px-10 py-3 rounded-sm bg-orange-400 mt-2"
              onClick={async event => {
                event.preventDefault()
                const query = (
                  document.getElementById('query') as HTMLInputElement
                ).value

                console.log(query)
                const result = await queryAoss({ query: query })
                document.getElementById('result')!.innerText = result
              }}
            >
              Query
            </button>
          </form>
        </div>
        <div>
          <p id="result"></p>
        </div>
      </div>
    </div>
  )
}

export default IndexPage

'use client'

import { Message } from 'ai'
import { useChat } from 'ai/react'

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: './api/rag'
  })

  // Generate a map of message role to text color
  const roleToColorMap: Record<Message['role'], string> = {
    system: 'red',
    user: 'black',
    function: 'blue',
    tool: 'purple',
    assistant: 'green',
    data: 'orange'
  }

  return (
    <div className="flex flex-col w-full max-w-md py-24 mx-auto stretch">
      {messages.length > 0
        ? messages.map(m => (
            <div
              key={m.id}
              className="whitespace-pre-wrap"
              style={{ color: roleToColorMap[m.role] }}
            >
              <strong>{`${m.role}: `}</strong>
              {m.content || JSON.stringify(m.function_call)}
              <br />
              <br />
            </div>
          ))
        : null}

      <form onSubmit={handleSubmit}>
        <input
          className="fixed bottom-0 w-full max-w-md p-2 mb-8 border border-gray-300 rounded shadow-xl"
          value={input}
          placeholder="Say something..."
          onChange={handleInputChange}
        />
      </form>
    </div>
  )
}

import {
  BedrockRuntime,
  InvokeModelCommand,
  InvokeModelWithResponseStreamCommand
} from '@aws-sdk/client-bedrock-runtime'
import { AWSBedrockAnthropicStream, StreamingTextResponse } from 'ai'

const { defaultProvider } = require('@aws-sdk/credential-provider-node')
const { Client } = require('@opensearch-project/opensearch')
const { AwsSigv4Signer } = require('@opensearch-project/opensearch/aws')

// IMPORTANT! Set the runtime to edge
// export const runtime = "edge";

const decoder = new TextDecoder()

const bedrockClient = new BedrockRuntime({
  region: process.env.REGION
  // region: process.env.AWS_REGION ?? process.env.REGION,
  // credentials: {
  //   accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? "",
  //   secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? "",
  //   sessionToken: process.env.AWS_SESSION_TOKEN ?? "",
  // },
})

const aossClient = new Client({
  ...AwsSigv4Signer({
    region: process.env.REGION,
    service: 'aoss',
    getCredentials: () => {
      const credentialsProvider = defaultProvider()
      return credentialsProvider()
    }
  }),
  node: process.env.AOSS_URL
})

const createEmbedVector = async doc => {
  const response = await bedrockClient.send(
    new InvokeModelCommand({
      modelId: 'amazon.titan-embed-text-v1',
      contentType: 'application/json',
      accept: 'application/json',
      body: JSON.stringify({
        inputText: doc
      })
    })
  )

  const vec = JSON.parse(decoder.decode(response.body))['embedding']
  console.log(vec.length)

  return vec
}

const queryAoss = async query => {
  const vec = await createEmbedVector(query)

  const body = {
    size: 2,
    query: {
      knn: {
        vector_field: {
          vector: vec,
          k: 2
        }
      }
    }
  }

  var response = await aossClient.search({
    index: 'demo',
    body: body
  })

  // for (let hit of response.body.hits.hits) {
  //   console.log(hit);
  // }

  let result = ''

  for (let hit of response.body.hits.hits) {
    result += hit._source.text
  }

  // console.log(result);

  return result
}

export async function POST(req) {
  // Extract the `prompt` from the body of the request
  const { messages } = await req.json()

  console.log(messages)

  // question last messages
  // const question = "what is developing on aws course?";

  const question = messages.pop().content

  console.log(question)

  // query opensearch get context

  let context = ''

  try {
    context = await queryAoss(question)
    console.log(context)
  } catch (error) {
    console.log(error)
  }

  const prompt = `\n\nHuman: Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. don't include harmful content \n\n ${context} \n\nHuman: ${question} \n\nAssistant:`

  // Ask Claude for a streaming chat completion given the prompt
  const bedrockResponse = await bedrockClient.send(
    new InvokeModelWithResponseStreamCommand({
      modelId: 'anthropic.claude-v2',
      contentType: 'application/json',
      accept: 'application/json',
      body: JSON.stringify({
        prompt: prompt,
        max_tokens_to_sample: 2048
      })
    })
  )

  // Convert the response into a friendly text-stream
  const stream = AWSBedrockAnthropicStream(bedrockResponse)

  // Respond with the stream
  return new StreamingTextResponse(stream)
}

FROM node:18-alpine AS base

# Install dependencies only when needed
FROM base AS deps
# Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.
RUN apk add --no-cache libc6-compat
WORKDIR /app

# Install dependencies based on the preferred package manager
COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* ./
RUN \
  if [ -f yarn.lock ]; then yarn --frozen-lockfile; \
  elif [ -f package-lock.json ]; then npm ci; \
  elif [ -f pnpm-lock.yaml ]; then corepack enable pnpm && pnpm i --frozen-lockfile; \
  else echo "Lockfile not found." && exit 1; \
  fi


# Rebuild the source code only when needed
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Next.js collects completely anonymous telemetry data about general usage.
# Learn more here: https://nextjs.org/telemetry
# Uncomment the following line in case you want to disable telemetry during the build.
# ENV NEXT_TELEMETRY_DISABLED 1

RUN \
  if [ -f yarn.lock ]; then yarn run build; \
  elif [ -f package-lock.json ]; then npm run build; \
  elif [ -f pnpm-lock.yaml ]; then corepack enable pnpm && pnpm run build; \
  else echo "Lockfile not found." && exit 1; \
  fi

# Production image, copy all the files and run next
FROM base AS runner
WORKDIR /app

ENV NODE_ENV production
# Uncomment the following line in case you want to disable telemetry during runtime.
# ENV NEXT_TELEMETRY_DISABLED 1

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public

# Set the correct permission for prerender cache
RUN mkdir .next
RUN chown nextjs:nodejs .next

# Automatically leverage output traces to reduce image size
# https://nextjs.org/docs/advanced-features/output-file-tracing
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT 3000
# set hostname to localhost
ENV HOSTNAME "0.0.0.0"

# server.js is created by next build from the standalone output
# https://nextjs.org/docs/pages/api-reference/next-config-js/output
CMD ["node", "server.js"]

import os
import boto3


# parameters
deploy = 1

# # parameters
REGION = "us-east-1"
ACCOUNT = os.environ["ACCOUNT_ID"]

# delete all docker images
os.system("sudo docker system prune -a")

# build next-bedrock image
os.system("sudo docker build -t next-bedrock . ")

#  aws ecr login
os.system(f"aws ecr get-login-password --region {REGION} | sudo docker login --username AWS --password-stdin {ACCOUNT}.dkr.ecr.{REGION}.amazonaws.com")

# get image id
IMAGE_ID=os.popen("sudo docker images -q next-bedrock:latest").read()

# tag next-bedrock image
os.system(f"sudo docker tag {IMAGE_ID.strip()} {ACCOUNT}.dkr.ecr.{REGION}.amazonaws.com/next-bedrock:latest")

# create ecr repository
os.system(f"aws ecr create-repository --registry-id {ACCOUNT} --repository-name next-bedrock")

# push image to ecr
os.system(f"sudo docker push {ACCOUNT}.dkr.ecr.{REGION}.amazonaws.com/next-bedrock:latest")

# run locally to test
# os.system(f"sudo docker run -d -p 3000:3000 next-bedrock:latest")


# apprunner deploy
if deploy == 1:
    apprunner = boto3.client('apprunner')
    apprunner.start_deployment(
     ServiceArn=f"arn:aws:apprunner:{REGION}:{ACCOUNT}:service/NextBedrockService/xxx"
     )