This is Day#2 of the #*ServerlessChallenge **challenge, where I'm creating/building serverless apps using different AWS services.*

Short description: An API that accepts a list of food/ingredients that I have and returns meal ideas that I can prepare.

The long/tech description

Using Amazon Bedrock (Jurassic-2 Mid model) to generate some meal ideas and the steps for preparing it after getting the input of the available ingredients and the number of needed meals:

The prompt text is so simple but it's enough to make sure that the output will be as I want, also the max number of tokens is limited to 200 which is enough Don't want to be surprised by the invoice 🏃-

  const command: InvokeModelCommand = new InvokeModelCommand({
    modelId: process.env.BEDROCK_TEXT_MODEL,
    contentType: "application/json",
    accept: "*/*",
    body: JSON.stringify(
      {
        prompt: `Recommend only ${numberOfMeals} meal(s) Which i can make only by using ${ingredients.join(',')}`,
        maxTokens: 200,
        temperature: 0.7,
        topP: 1
      }
    )
  });

The trigger of the lambda function is the endpoint /meals (API Gateway) with the following event schema which has the list of the ingredients & the needed number of meals:

default {
  type: "object",
  properties: {
    ingredients: {type: 'string'},
    count: {type: 'number'}
  },
  required: ['ingredients', 'count']
} as const;

  events: [
    {
      http: {
        method: 'get',
        path: 'meals',
        request: {
          schemas: {
            'application/json': schema,
          },
        },
      },
    },
  ]

So, to wrap that up, simple the function is:

• Receiving a list of ingredients and the number of meals

• Invoking the model to get some meal ideas

• Responding with the ai response

GitHub repo: https://github.com/Rochdy/mealsRecommender

That was the app of Day#2! looking forward to posting soon about the next app

This is Day#1 of the #ServerlessChallenge, where I'm creating/building serverless apps using different AWS services.

The short description: an app sends me a WhatsApp message every day to teach me a random Spanish word with its meaning.

The long/tech description

Using the serverless framework, I've built a simple lambda function that is being triggered with an EventBridge rule:

events: [
  {
    schedule: {
      rate: ["rate(1 day)"]
    }
  }
]

EventBridge rules are so simple and interesting to write, as example if you want to write a rule that triggers an event on only the work days at 9 am, it will be like this: cron(0 9 ? MON-FRI )

The lambda function is so small, what it does:

• Getting a random Spanish word using paunovic/random-words

• Translate this word using bing-translate-api

• Send a good-formatted WhatsApp every day with the word and its translation using Twilio

        // src/functions/teach/index.ts

        const word = RANDOM.word();
        const translation = await translate(word, 
            'process.env.LANGUAGE_TO',
            'process.env.LANGUAGE_FROM'
        );
        const message = {
            from: `whatsapp:${process.env.TWILIO_SENDER}`,
            body: `Hola! 🙋 \n
                   Today's word is: *${translation.text}* \n
                   Which means: *${translation.translation}*`,
            to: `whatsapp:${process.env.TWILIO_RECEIVER}`
        };

        await client.messages.create(message);

And as my favorite song says: ♫ Don't place the API key/secrets & configs in the code directly, my friend ♫

You can safely store any keys/secrets/configs inside the serverless configuration provider.environment and they will be added as env variables for the lambda function

// serverless.ts
const serverlessConfiguration: AWS = {
  //..
  provider: {
    environment: {
      TWILIO_ACCOUNT_SID: 'xx',
      TWILIO_AUTH_TOKEN: 'xx',
      TWILIO_SENDER: 'xx',
      TWILIO_RECEIVER: 'xx',
      LANGUAGE_TO: 'es',
      LANGUAGE_FROM: 'en'
    },
  },
}

the github repo: https://github.com/Rochdy/teachMeSpanish

That was the app of Day#1! looking forward to posting soon about the next app of the challenge.