Getting started with Generative AI prompt engineer Step By Step Guide

 Generative AI prompt engineering involves crafting effective prompts to elicit desired responses from generative models.

Whether you're working with any models, the key is to provide clear and specific instructions. Here's a step-by-step guide to get started:

1. Understand the Model's Capabilities:

   • Familiarize yourself with the capabilities and limitations of the generative model you're using. Understand the types of tasks it can perform and the formats it accepts.

2. Define Your Goal:

   • Clearly define the goal of your prompt. Are you looking for creative writing, programming code, problem-solving, or something else? The specificity of your goal will guide your prompt creation.

3. Start with a Clear Instruction:

   • Begin your prompt with a clear and concise instruction. Be specific about the type of output you're expecting. For example, if you want a creative story, you might start with "Write a short story about..."

4. Provide Context or Constraints:

   • If necessary, provide additional context or constraints to guide the model. This can include setting, characters, tone, or any specific requirements. Constraints help to narrow down the output and make it more relevant to your needs.

5. Experiment with Temperature and Max Tokens:

   • Generative models often come with parameters like "temperature" and "max tokens." Temperature controls the randomness of the output, and max tokens limit the length of the response. Experiment with these parameters to fine-tune the model's behavior.

6. Iterate and Refine:

   • Don't be afraid to iterate and refine your prompts. Experiment with different instructions, wording, and structures to achieve the desired output. Analyze the model's responses and adjust your prompts accordingly.

7. Use System and User Messages:

   • For interactive conversations with the model, you can use both system and user messages. System messages set the behavior of the assistant, while user messages simulate the user's input. This can be useful for multi-turn interactions.

8. Handle Ambiguity:

   • If your prompt is ambiguous, the model might produce unexpected or undesired results. Clarify your instructions to reduce ambiguity and improve the likelihood of getting the desired output.

9. Consider Prompt Engineering Libraries:

   • Some platforms provide prompt engineering libraries that simplify the process of crafting effective prompts. For example, OpenAI's Playground or other third-party libraries may offer useful tools and examples.

10. Stay Ethical:

    • Be mindful of ethical considerations when generating content. Avoid prompts that may lead to harmful or inappropriate outputs. Review and filter the generated content to ensure it aligns with ethical guidelines.

Prompt engineering often involves a trial-and-error process. As you experiment and become familiar with the model's behavior, you'll improve your ability to craft effective prompts for generative AI.

API rate limiting strategies for Spring Boot applications

 

API Rate Limiting

 Rate limiting is a strategy to limit access to APIs. 

 It restricts the number of API calls that a client can make within a certain time frame. 

 This helps defend the API against overuse, both unintentional and malicious.

API rate limiting is crucial for maintaining the performance, stability, and security of Spring Boot applications. Here are several rate limiting strategies you can employ:

1. Fixed Window Counter:

In this strategy, you set a fixed window of time (e.g., 1 minute), and you allow a fixed number of requests within that window. If a client exceeds the limit, further requests are rejected until the window resets. This approach is simple but can be prone to bursts of traffic.

2. Sliding Window Counter:

A sliding window counter tracks the number of requests within a moving window of time. This allows for a more fine-grained rate limiting mechanism that considers recent activity. You can implement this using a data structure like a sliding window or a queue to track request timestamps.

3. Token Bucket Algorithm:

The token bucket algorithm issues tokens at a fixed rate. Each token represents permission to make one request. Clients consume tokens for each request, and requests are only allowed if there are available tokens. Google's Guava library provides a RateLimiter class that implements this algorithm.

4. Leaky Bucket Algorithm:

Similar to the token bucket, the leaky bucket algorithm releases tokens at a constant rate. However, in the leaky bucket, the bucket has a leak, allowing it to empty at a constant rate. Requests are processed as long as there are tokens available. This strategy can help smooth out bursts of traffic.

5. Distributed Rate Limiting with Redis or Memcached:

If your Spring Boot application is distributed, you can use a distributed caching system like Redis or Memcached to store and share rate limiting information among different instances of your application.

6. Spring Cloud Gateway Rate Limiting:

If you're using Spring Cloud Gateway, it provides built-in support for rate limiting. You can configure rate limiting policies based on various criteria such as the number of requests per second, per user, or per IP address.

7. User-based Rate Limiting:

Instead of limiting based on the number of requests, you can implement rate limiting on a per-user basis. This is useful for scenarios where different users may have different rate limits based on their subscription level or user type.

8. Adaptive Rate Limiting:

Implement adaptive rate limiting that dynamically adjusts rate limits based on factors such as server load, response times, or the health of the application. This approach can help handle variations in traffic.

9.Response Code-based Rate Limiting:

Consider rate limiting based on response codes. For example, if a client is generating a high rate of error responses, you might want to impose stricter rate limits on that client.

10. API Key-based Rate Limiting:

Tie rate limits to API keys, allowing you to set different limits for different clients or users. This approach is common in scenarios where you have third-party developers using your API.

How to install Kong Gateway using Docker

To install Kong Gateway, you can follow these steps: 

 Step 1: Choose the installation method: 

  

     Kong Gateway offers different installation methods depending on your operating system and

     requirements. 

    You can choose from Docker, package managers (e.g., Homebrew, Yum, Apt), or manual installation.

     For simplicity, let's go with the Docker installation method.

 Step 2: Install Docker: If you don't have Docker installed, visit the Docker website

              (https://www.docker.com/) and follow the instructions to install Docker for your specific

               operating system. 

 Step 3: Pull the Kong Gateway Docker image: 

 

             Open a terminal or command prompt. Run the following command to pull the Kong Gateway

              Docker image from Docker Hub:

docker pull kong/kong-gateway

Step 4: Run Kong Gateway container: Once the image is pulled, run the following command to start a

             Kong Gateway

docker run -d --name kong-gateway \
  -e "KONG_DATABASE=off" \
  -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
  -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
  -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
  -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
  -e "KONG_ADMIN_LISTEN=0.0.0.0:8001" \
  -e "KONG_PROXY_LISTEN=0.0.0.0:8000" \
  -p 8000:8000 \
  -p 8001:8001 \
  kong/kong-gateway

This command starts a Kong Gateway container named "kong-gateway" with the necessary environment variables and port mappings. 

 The -p option maps the container's ports to the host machine, allowing access to Kong Gateway's admin API (port 8001) and proxy API (port 8000). 

 The -e options set various environment variables like the database type (KONG_DATABASE=off disables the database), log configurations, and listen addresses.

 Step 5: Verify Kong Gateway installation: After running the container, wait for a few moments to allow

              Kong Gateway to initialize. 

You can check the logs of the container using the following command:

docker logs kong-gateway

Look for any error messages or indications that Kong Gateway has started successfully. 

 Step 6: Access Kong Gateway admin API: 

 Once Kong Gateway is running, you can access its admin API to configure and manage your Kong Gateway instance. 

Open a web browser and go to http://localhost:8001. You should see the Kong Gateway admin API homepage if everything is working correctly.

 Congratulations! You have successfully installed Kong Gateway using Docker. 

You can now proceed with configuring Kong Gateway and integrating it with your applications as needed

How to Implement Image classification using TensorFlow maven and Java

Here is an example of using TensorFlow with Java and Maven to perform image classification: 

 1.Create a new Maven project in your favorite IDE. 

 2. Add the TensorFlow Java dependency to your project by adding the following to your pom.xml file:

    
      <dependencies>
    <dependency>
        <groupId>org.tensorflow</groupId>
        <artifactId>tensorflow</artifactId>
        <version>2.7.0</version>
    </dependency>
</dependencies>
    

3. Create a new class, for example ImageClassifier.java, and add the following code:

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import org.tensorflow.DataType;
import org.tensorflow.Graph;
import org.tensorflow.Session;
import org.tensorflow.Tensor;
import org.tensorflow.TensorFlow;

public class ImageClassifier {
    private static byte[] loadImage(String path) throws IOException {
        BufferedImage img = ImageIO.read(new File(path));
        int height = img.getHeight();
        int width = img.getWidth();
        int channels = 3;
        byte[] data = new byte[height * width * channels];
        int pixel = 0;
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                int rgb = img.getRGB(j, i);
                data[pixel++] = (byte) ((rgb >> 16) & 0xFF);
                data[pixel++] = (byte) ((rgb >> 8) & 0xFF);
                data[pixel++] = (byte) (rgb & 0xFF);
            }
        }
        return data;
    }

    public static void main(String[] args) throws Exception {
        // Load the TensorFlow library
        try (Graph g = new Graph()) {
           byte[] graphBytes = TensorFlowModelLoader.load("path/to/model.pb");
            g.importGraphDef(graphBytes);

            // Create a new session to run the graph
            try (Session s = new Session(g)) {
                // Load the image data
                String imagePath = "path/to/image.jpg";
                byte[] imageBytes = loadImage(imagePath);

                // Create a tensor from the image data
                Tensor inputTensor = Tensor.create(new long[]
                                   {1, imageBytes.length}, ByteBuffer.wrap(imageBytes));

                // Run the graph on the input tensor
                Tensor outputTensor = s.runner()
                        .feed("input", inputTensor)
                        .fetch("output")
                        .run()
                        .get(0);

                // Print the predicted label
                DataType outputDataType = outputTensor.dataType();
                long[] outputShape = outputTensor.shape();
                Object[] output = new Object[outputTensor.numElements()];
                outputTensor.copyTo(output);
                System.out.println("Prediction: " + output[0]);
            }
        }
    }
}

4. Replace the path/to/model.pb and path/to/image.jpg with the actual paths to your model and image files. 

 5. Run the ImageClassifier class, and it should print out the predicted label for the input image.

How to create key cloak authentication server and spring boot

To create a Keycloak authentication server, you need to follow these steps: 

 1. Download and Install Keycloak: You can download Keycloak from the official website     

        https://www.keycloak.org/downloads.html.

 Follow the installation instructions provided in the documentation. 

 2. Configure Keycloak: Once installed, you need to configure Keycloak by creating a new realm. 

     A realm is a container for all the users, roles, and groups in your application.

    To create a new realm, log in to the Keycloak admin console using the default credentials

      (admin/admin), then follow these steps:

      Click on the "Add Realm" button and provide a name for your realm. 

      Configure your realm settings, including themes, email settings, and login settings. 

      Create users and groups within your realm and assign roles to them. 

 3. Set Up Your Spring Boot Application: You can use the Keycloak Spring Boot Starter dependency to

      add Keycloak authentication to your Spring Boot application.

      Add the following dependency to your Maven or Gradle build file:

<dependency>
  <groupId>org.keycloak</groupId>
  <artifactId>keycloak-spring-boot-starter</artifactId>
</dependency>

4. Configure Your Spring Boot Application: You need to configure your Spring Boot application to

     connect to the Keycloak server. 

     You can do this by adding the following properties to your application.properties or application.yml file:

keycloak.auth-server-url=<keycloak-server-url>
keycloak.realm=<keycloak-realm>
keycloak.resource=<keycloak-client-id>
keycloak.credentials.secret=<keycloak-client-secret>

   Replace <keycloak-server-url>, <keycloak-realm>, <keycloak-client-id>, 

    and <keycloak-client-secret> with the appropriate values for your Keycloak instance.

 5.  Secure Your Spring Boot Application: You can secure your Spring Boot application by adding the

      Keycloak configuration to your Spring Security configuration. 

      You can do this by creating a new class that extends KeycloakWebSecurityConfigurerAdapter and

      override the configure method. 

Here's an example:

@Configuration
@EnableWebSecurity
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class SecurityConfig extends KeycloakWebSecurityConfigurerAdapter {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(keycloakAuthenticationProvider());
    }

    @Bean
    public KeycloakSpringBootConfigResolver keycloakConfigResolver() {
        return new KeycloakSpringBootConfigResolver();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.authorizeRequests().antMatchers("/admin/**").hasRole("admin")
          .antMatchers("/user/**").hasAnyRole("user", "admin")
          .anyRequest().permitAll();
    }
}

    This configuration class enables Keycloak authentication and authorization for specific URLs in the

     application.

 6. Test Your Application: You can test your application by running it and accessing the protected URLs.

     When a user tries to access a protected resource, they will be redirected to the Keycloak login page.

      Once they successfully authenticate, they will be redirected back to the original resource. 

That's it! we have created a Keycloak authentication server and secured your Spring Boot application with it.

How to build video conference using spring boot

To build a video conference application using Spring Boot, you can follow these steps: 

 1. Choose a video conferencing API: There are several video conferencing APIs available such as Twilio, Agora, Zoom, Jitsi, etc. Choose an API that best fits your requirements. 

 2. Set up a Spring Boot project: Create a new Spring Boot project using your preferred IDE or by using Spring Initializr. 

 3. Add the video conferencing API dependencies: Add the necessary dependencies for the chosen API in your project's pom.xml file.

 4. Configure the video conferencing API: Configure the video conferencing API with the required credentials and other settings in your Spring Boot application's configuration file.

 5. Implement the video conferencing features: Use the API's SDK to implement the video conferencing features such as creating a conference room, joining a room, leaving a room, etc. 

 6. Integrate the video conferencing features with your application: Add the necessary controllers and views to your Spring Boot application to integrate the video conferencing features with your application. 

 7. Test the application: Test the application thoroughly to ensure that the video conferencing features are working as expected. 

 Here's a sample code for a video conference application using Spring Boot and the Twilio Video API:

 1. Add the Twilio Video API dependency to your pom.xml file:

 

<dependency>
    <groupId>com.twilio.sdk</groupId>
    <artifactId>twilio</artifactId>
    <version>7.54.0</version>
</dependency>

2. Add the required Twilio credentials and settings to your Spring Boot application's application.properties file

twilio.account.sid=your_account_sid
twilio.auth.token=your_auth_token
twilio.api.key=your_api_key
twilio.api.secret=your_api_secret
twilio.video.room.max-participants=4

3. Implement a controller for creating and joining a video conference room:

@RestController
public class VideoConferenceController {

    @Autowired
    private TwilioConfig twilioConfig;

    @PostMapping("/room")
    public ResponseEntity createRoom() throws Exception {
        RoomCreator roomCreator = Room.creator()
                .setUniqueName(UUID.randomUUID().toString())
                .setType(RoomType.PEER_TO_PEER)
                .setStatusCallback(twilioConfig.getStatusCallback())
                .setMaxParticipants(twilioConfig.getMaxParticipants());
        Room room = roomCreator.create();
        RoomResponse response = new RoomResponse();
        response.setRoomId(room.getSid());
        response.setRoomName(room.getUniqueName());
        response.setToken(createAccessToken(room.getSid()));
        return ResponseEntity.ok(response);
    }

    @GetMapping("/room/{roomId}/token")
    public ResponseEntity 
                        getRoomToken(@PathVariable("roomId") String roomId) {
        String accessToken = createAccessToken(roomId);
        return ResponseEntity.ok(accessToken);
    }

    private String createAccessToken(String roomId) {
        VideoGrant grant = new VideoGrant();
        grant.setRoom(roomId);
        AccessToken token = new AccessToken.Builder(
                twilioConfig.getAccountSid(),
                twilioConfig.getApiKey(),
                twilioConfig.getApiSecret()
        ).identity(UUID.randomUUID().toString())
                .grant(grant)
                .build();
        return token.toJwt();
    }

}

4.Define a configuration class for the Twilio settings:

@ConfigurationProperties(prefix = "twilio")
@Data
public class TwilioConfig {

    private String accountSid;
    private String authToken;
    private String apiKey;
    private String apiSecret;
    private String statusCallback;
    private int maxParticipants;


}

5.Configure the Twilio settings in your Spring Boot application's application.yml file:

twilio:
  account-sid: your_account_sid
  auth-token: your_auth_token
  api-key: your_api_key
  api-secret: your_api_secret
  status-callback: http://localhost:8080/callback
  max-participants: 4
  
  

6. Run your Spring Boot application and test the video conference feature by creating and joining a room using the API endpoints.

Oracle Cloud Infrastructure- Object storage example

This post will explain, how we can create bucket and configure notification and rules and object storage like create/update object. Login into OCI using login credentials . if you don't have a account please create the same using this link https://www.oracle.com/cloud/sign-in.html Once you create account and successful login, Now we need to create a bucket. search for bucket and create a bucket

After creating bucket now we can create a topic

Now we can create notification, after uploading file , we should get email

Create a Rule to process this

Once we create all then , once we upload file in object storage , then we should get email like below

This shows we can send email, but we can configure with different ways like queues. Here we will get the details in mail . But if we want complete object details, then we can use java code to retrieve the object details by calling the API which required namespace details ,bucket name and object name.

import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Paths;
import java.util.List;

import com.oracle.bmc.objectstorage.ObjectStorage;
import com.oracle.bmc.objectstorage.ObjectStorageClient;
import com.oracle.bmc.objectstorage.model.GetObjectRequest;
import com.oracle.bmc.objectstorage.model.ObjectStream;
import com.oracle.bmc.objectstorage.model.Range;
import com.oracle.bmc.objectstorage.requests.GetObjectRequest;
import com.oracle.bmc.objectstorage.responses.GetObjectResponse;

public class LogFileRetriever {
    public static void main(String[] args) {
        String namespaceName = "mynamespace";
        String bucketName = "mybucket";
        String objectName = "mylogfile.txt";

        // Create a new Object Storage client
        ObjectStorage objectStorageClient = ObjectStorageClient.builder()
                .build(objectStorageConfig);

        GetObjectRequest request = GetObjectRequest.builder()
                .namespaceName(namespaceName)
                .bucketName(bucketName)
                .objectName(objectName)
                .build();

        GetObjectResponse response = objectStorageClient.getObject(request);

        // Get the InputStream from the response
        InputStream logFileInputStream = response.getInputStream();

        // Write the InputStream to a local file
        OutputStream logFileOutputStream = 
            new FileOutputStream(Paths.get("logfile.txt").toFile());
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = logFileInputStream.read(buffer)) != -1) {
            logFileOutputStream.write(buffer, 0, bytesRead);
        }
        logFileOutputStream.close();
    }
}