Full Stack AI Engineer Test (LLMs, Agents and MCPs)

You are asked to create a prompt for a language model that outputs JSON data for a company's employee database. The JSON must include an employee's ID, name, age, and whether they are currently active. Consider how you might structure your prompt given these fields. Identify the best prompt design.

Example JSON output:
{
   "ID": "123",
   "Name": "John Doe",
   "Age": 30,
   "Active": true
}

Which prompt structure would most effectively guide the language model to generate the correct JSON format?
A: Create JSON objects for employees with fields: ID, Name, Age, Active. ID should be a string.
B: Generate JSON data: ID, Name, Age, Active. ID is a number.
C: Output JSON: ID (string), Name, Age (integer), Active (boolean).
D: Make JSON: ID, Name, Age, Active. ID is always number.
E: Design JSON response: ID, Name, Age, Active with clear typing.
F: Provide JSON example: Employee data with structured fields.

Consider the following prompt given to an LLM:

System Prompt: "You are a creative writing assistant helping authors develop character descriptions. Use vivid imagery and engaging language to bring characters to life."
Main Prompt: "Write a character description for a mysterious librarian with the following traits:

Works in an ancient library
Has silver hair and green eyes
Knows secrets about forbidden books
Appears to be in their 40s but seems much older
Always wears a pendant with strange symbols"

Three outputs were generated with different temperature settings:

Output A:
"The librarian possesses silver hair and green eyes. Age appears to be approximately 40 years. Works in an ancient library facility. Has knowledge of restricted book collections. Wears jewelry featuring symbolic markings. Maintains professional demeanor while handling library materials."
Output B:
"Elara moves through the ancient library like a ghost haunting familiar halls, her silver hair catching moonbeams that slip through Gothic windows. Those emerald eyes hold centuries of secrets—too many secrets for someone who claims only four decades of life. The obsidian pendant at her throat pulses with runes that predate any known language, and when she speaks of the forbidden texts, her voice carries the weight of ages. There's something unsettling about how she never seems surprised by anything, as if she's been waiting lifetimes for each visitor to find their way to her domain."
Output C:
"Meet Elara, the enigmatic keeper of knowledge whose silver locks frame a face that defies time itself. Her piercing green eyes seem to peer directly into your soul, holding secrets that could unravel reality. The ancient library around her creaks with whispered stories, and she alone holds the keys to the forbidden sections where dangerous truths slumber. The mystical pendant adorning her neck bears symbols older than civilization, pulsing with otherworldly energy that hints at her true nature."

Which temperature setting was most likely used for each output?
A) Output A (T=0.1), Output B (T=1.0), Output C (T=0.5)
B) Output A (T=0.5), Output B (T=0.1), Output C (T=1.0)
C) Output A (T=0.1), Output B (T=0.5), Output C (T=1.0)
D) Output A (T=1.0), Output B (T=0.5), Output C (T=0.1)
E) Output A (T=0.5), Output B (T=1.0), Output C (T=0.1)

Consider the following Dockerfile, which utilizes multistage builds. The aim is to build a lightweight, optimized image that just runs the application.

The Dockerfile first defines a base image that includes Node.js and npm, then it creates an intermediate image to install the npm dependencies. Afterwards, it runs the tests in another stage and finally, creates the release image.

Which of the following statements are true?

A: The final image will include the test scripts.
B: If a test fails, the final image will not be created.
C: The node_modules directory in the final image comes from the base image.
D: The final image will only contain the necessary application files and dependencies.
E: If the application's source code changes, only the release stage needs to be rebuilt.

You have two docker containers, X and Y. Container X is running a web service listening on port 8080, and container Y is supposed to consume this service. Both containers are created from images that don't have any special network configurations.

Container X has a Dockerfile as follows:

And, you build and run it with the following commands:

Container Y is also running alpine with python installed, and it's supposed to read data from the `/app/data` directory and send a GET request to `http://localhost:8080` every 5 minutes. The Dockerfile for container B is:

And you run it with:

Assuming all the python scripts work perfectly and firewall isn't blocking any connections, you find that container Y can't access the web service of container X via `http://localhost:8080` and also it can't read the data in `/app/data` directory. What could be the potential reason(s)?

A: Y can't access X's web service because they're in different Docker networks.
B: Y can't read the data because the volume is not shared correctly.
C: Both A and B are correct.
D: Both A and B are incorrect.

You have been asked to optimize a Dockerfile for a Python application that involves a heavy dependency installation. Here is the Dockerfile you are starting with:

Given that the application's source code changes frequently but the dependencies listed in requirements.txt rarely change, how can you optimize this Dockerfile to take advantage of Docker's layer caching, reducing the build time?

A: Move the `RUN pip install` command to before the `COPY` command.
B: Change `COPY . /app` to `COPY ./app.py /app` and move the `RUN pip install` command to before the `COPY` command.
C: Add `RUN pip cache purge` before `RUN pip install`.
D: Replace the base image with `python:3.8-slim`.
E: Implement multi-stage builds.

Check the following Dockerfile used for a project (STAGE 1):

We created an image from this Dockerfile on Dec 14 2021. A couple of weeks after Dec 14 2021, Ubuntu released new security updates to their repository. After 2 months, we modified the file (STAGE 2):

Couple of weeks later, we further modified the file to add a local file ada.txt to /ada.txt (STAGE 3): (Note that ada.txt exists in /home/adaface and the dockerfile exists in /home/code folders)

Pick correct statements:

A: If we run “docker build .” at STAGE 2, new Ubuntu updates will be fetched because apt-get update will be run again since cache is invalidated for all lines/layers of Dockerfile when a new line is added.
B: If we run “docker build .” at STAGE 2, new Ubuntu updates will not be fetched since cache is invalidated only for last two lines of the updated Dockerfile. Since the first two commands remain the same, cached layers are re-used skipping apt get update.
C: To skip Cache, “docker build -no-cache .” can be used at STAGE 2. This will ensure new Ubuntu updates are picked up.
D: Docker command “docker build .” at STAGE 3 works as expected and adds local file ada.txt to the image.
E: Docker command “docker build .” at STAGE 3 gives an error “no such file or directory” since /home/adaface/ada.txt is not part of the Dockerfile context.

Review the following Dockerfiles that work on two projects (project and project2):

All Docker files have the same end result:

- ‘project’ is cloned from git. After running few commands, ‘project’ code is removed.
- ‘project2’ is copied from file system and permissions to the folder is changed.

Pick the correct statements:

A: File 1 is the most efficient of all.
B: File 2 is the most efficient of all.
C: File 3 is the most efficient of all.
D: File 4 is the most efficient of all.
E: Merging multiple RUN commands into a single RUN command is efficient for ‘project’ since each RUN command creates a new layer with changed files and folders. Deleting files with RUN only marks these files as deleted but does not reclaim disk space. 
F: Copying ‘project2’ files and changing ownership in two separate commands will result in two layers since Docker duplicates all the files twice.

A web app for a popular AI conference (conducted in New York, with attendees from around the world) uses a signup/login page before users can access their dashboard. The signup/login page uses a form for users to input details and submit. The details are then sent to the backend service for processing. All user actions are logged in a log server. Senior Frontend Engineer, Musk, observed patterns in the issues users are facing with the the web app. Here are the two common patterns that Musk observed in the issues that have been occurring for most users:

Which of the following should Musk do to enhance the user experience with the page?

A: Implement validation using JS event listeners on client-side (e.g., on input or change)
B: Utilize HTML5 built-in form validation attributes (e.g., required, pattern)
C: Use server-side validation and refresh the page on form submission
D: Use a serverless function that processes the user’s form details, saves the user’s entries in the database and responds with validation data

A senior front-end engineer is tasked with optimizing the loading speed of a web application. The current bottleneck is the large number of JavaScript files that must be downloaded before the application becomes interactive. The engineer noticed that the browser spends a lot of time parsing and executing the JS code before making the application interactive. Which of the following techniques should the engineer apply to address this issue?

You are working on a large-scale, distributed, and fault-tolerant message processing system designed to handle high throughput and low latency requirements. The system is based on the publish-subscribe pattern and uses multiple brokers to distribute messages across various topics and partitions. In this architecture, both publishers and subscribers are considered clients. The brokers are responsible for replicating messages among themselves to ensure fault tolerance and data durability.

A client reports successfully publishing a message on a specific topic. However, one of the subscribers has not received the message. To investigate the issue, you have gathered detailed logs and system design data, as shown below:

Based on the information provided, which of the following is the most likely reason for the issue?

A: The message was not published on the topic
B: Client C is not subscribed to the correct topic
C: There is a replication lag between brokers B1 and B2
D: Client C is consuming from the wrong broker
E: The message processing system failed to acknowledge the message

A backend service is experiencing intermittent latency spikes while processing incoming requests. The service is deployed in a multi-node environment with a load balancer in front. You suspect that the issue might be related to resource contention. You collect the following performance metrics from the affected nodes during a spike:

Which of the following is the most probable cause of the latency spikes?
A: High memory usage on the affected nodes.
B: Disk I/O bottlenecks on the affected nodes.
C: Insufficient CPU resources on the affected nodes.
D: Uneven distribution of incoming requests by the load balancer.
E: Network latency between the load balancer and the backend nodes.

Consider a distributed e-commerce platform designed to handle high traffic volumes and ensure data consistency across its services. The platform uses a distributed database that replicates data across multiple nodes to increase availability and performance. To balance the load, it employs a load balancer that distributes user requests evenly across these nodes. The system is designed to tolerate the failure of up to two nodes without affecting the platform's overall availability.

Given the critical requirement for strong consistency to prevent issues such as overselling of products, the system uses a consensus algorithm for replication. The database is configured with a replication factor of 5, meaning each piece of data is stored on 5 nodes. For read and write operations to be considered successful, they must be acknowledged by a majority of the nodes involved in the operation.

Assuming all nodes have equal hardware resources and network latency between nodes is negligible, which of the following configurations would best meet the platform's requirements for high availability, performance, and strong consistency?

A: Reads require acknowledgment from 2 nodes, and writes require acknowledgment from 4 nodes.
B: Reads and writes both require acknowledgment from 3 nodes.
C: Reads require acknowledgment from 3 nodes, and writes require acknowledgment from 2 nodes.
D: Reads and writes both require acknowledgment from 4 nodes.
E: Reads require acknowledgment from 1 node, and writes require acknowledgment from 5 nodes.
F: Reads and writes both require acknowledgment from 5 nodes.

TransitTrack is a logistics company that needs to store real-time location data (latitude, longitude) of their vehicles as they move across the city. The system should be optimized for fast read and write operations to provide real-time tracking. TransitTrack can tolerate occasional data loss since the vehicle locations are updated frequently. Which of the following data storage solutions should TransitTrack implement for their vehicle tracking system?

A: Utilize a relational database management system (RDBMS) like PostgreSQL with a table indexed on the vehicle_id column for efficient data insertion and retrieval.
B: Implement an in-memory cache like Redis to store the vehicle location data, with the vehicle_id as the key and the latitude-longitude pair as the value.
C: Use a document-oriented database like MongoDB to store the vehicle location data as GeoJSON documents, enabling geospatial querying capabilities.
D: Develop a custom in-memory data structure using a spatial indexing technique like an R-tree to store and query the vehicle location data efficiently.
E: Use a time-series database like InfluxDB to store the vehicle location data along with timestamps, allowing for efficient querying and analysis of historical location data.

Johnny Bravo is setting up a new e-commerce store for men's clothing. He set up session stickiness with ELB. But he does not want ELB to manage the cookie, he wants the application to manage the cookie. When the server instance, which is bound to a cookie, crashes what do you expect will happen?

A: ELB will throw an error due to cookie unavailability
B: The response will have a cookie but stickiness will be deleted
C: The session will be sticky and ELB will route requests to another server as ELB keeps replicating the Cookie
D: The session will not be sticky until a new cookie is inserted

Imagine you’re a developer at Songbird Inc, working on a music editing app for mobile devices. The app allows users to edit audio clips and export them in various audio formats. Once a user finishes editing a clip, they can choose an output format and initiate the encoding process. This encoding process can take a while depending on the chosen format and the length of the clip. Because it’s a mobile app, you want to avoid freezing the UI while encoding is in progress.

What’s the most appropriate approach to notify the user when the encoding is complete and the exported file is ready?

A: Directly modify the UI elements from within the encoding logic. When encoding finishes, the encoding system can directly tell the UI components to update themselves with the new information (e.g., change a button text to “Export Complete”).
B: Separate the UI update logic from the encoding process. The encoding system should trigger a custom event (e.g., “EncodingFinishedEvent”) upon completion. UI components can listen for this event and update themselves accordingly when it’s received.
C:  Have the UI code continuously check on the encoding status with a loop (often referred to as busy waiting or polling). The loop would keep checking a flag or variable set by the encoding system until the encoding is complete. Once complete, the UI can update itself.
D:  Introduce a central message queue or event bus. The encoding system can publish a message to the message queue upon finishing the task. Separate UI update logic would be subscribed to the queue, listening for relevant messages. When it receives the message about encoding completion, it can update the UI.
E: Let the encoding logic return a callback function to the UI layer when it’s initiated. Once encoding is finished, the encoding system calls back this function, allowing the UI to update itself.