The Path to Become an AI Engineer: Building a Real-World AI Application

AI is revolutionizing industries across the globe, creating unprecedented demand for professionals who can bridge the gap between theoretical machine learning and practical software engineering.

Finding skilled software engineers or AI specialists individually is challenging enough—finding someone with strong foundations in both fields is even more difficult. That’s why BEON.tech created a specialized six-month program to help developers acquire the skills needed to become full-fledged AI Engineers.

In this article, I’ll walk you through how I tackled the final project of this program, building a functional AI system from scratch in just two weeks.

The Challenge: Creating a Smart Recipe Recommendation System

Our assignment was to develop a personalized meal recommendation system for a fictional company called TastyAI within a tight two-week timeline. The system needed to:

1. Process Natural Language: Understand user preferences, dietary restrictions, and specific requests
2. Generate Recipes: Provide structured recipes with ingredients and step-by-step instructions
3. Translate Content: Automatically translate recipes into multiple languages
4. Create Visual Content: Generate AI images representing the recommended meals
5. Work with Real Data: Utilize and process an actual recipe dataset

Tackling Big Data: Wrestling with 2.2 Million Recipes

Understanding the Dataset

My first challenge was handling a massive dataset—2,231,142 rows across 7 columns, totaling 2.14 GB. The data included titles, ingredients, directions, and a crucial Named Entity Recognition (NER) column.

Making Strategic Data Decisions

After analyzing what I was working with, I simplified by:

• Removing unnecessary columns (index, link, source)
• Focusing on critical information (title, ingredients, directions)
• Leveraging the NER column to identify ingredients users might want to include or avoid

Creating a Vector Database for Efficient Searches

To make this data searchable, I needed to:

1. Convert Text to Vectors: I selected the lightweight, open-source all-MiniLM-L6-v2 model for embedding
2. Choose the Right Storage Solution: After hitting limitations with ChromaDB due to the data volume, I switched to PGVector with PostgreSQL backend, which handled the massive dataset without breaking a sweat

Building a Conversational User Experience

Creating an Intuitive Chat Interface

For the user interface, I chose Streamlit—an open-source tool that makes building interactive apps quick and painless, with built-in support for LLM chat applications.

Selecting the Perfect AI Model

For the conversational component, I went with gpt-4o-mini, striking an excellent balance between cost-effectiveness and performance quality. Now, users were able to freely ask for recipes, inform restrictions, and specify ingredients to use or avoid, all in natural language.

A few minutes later, the app looked like this:

Keeping the AI Focused on Food

Lastly, to ensure the LLM stayed on topic, I implemented detailed system instructions:

{

           “role”: ROLE_SYSTEM,

           “content”: “””You are an AI culinary assistant powered by a sophisticated recipe recommendation system. Your primary function is to help users discover personalized meal suggestions from our curated recipe database. Here’s how you operate:

           1. Recipe Search & Recommendations:

           – Process natural language queries to find relevant recipes from the database

           – Consider dietary preferences and restrictions when suggesting meals

           – Provide semantically similar alternatives when exact matches aren’t found

           – Focus on recipes that are actually available in our database

           2. Recipe Information Delivery:

           – Present structured recipes with clear ingredients and instructions

           – Mention any dietary categories (vegetarian, vegan, gluten-free, etc.)

           3. Communication Guidelines:

           – Use a friendly, helpful tone

           – Reply on the same language as the user

           – If a specific recipe isn’t found, suggest similar alternatives

           – Always stay within the scope of available recipes

           – Be transparent about limitations

           Remember that you can only recommend recipes that exist in our database. Don’t invent or generate new recipes. If you’re unsure about specific details, acknowledge this and stick to the information available in our database.

           “””,

       }

It wasn’t enough to simply rely on the LLM to know when it should search the vector database for a recipe. To solve this, I leveraged a powerful new feature available in some LLMs: tools.

Teaching the AI to Search: Implementing LLM Tools

Connecting the Chat to Our Database

A key feature that brought real power to the system was the implementation of LLM tools (also known as function calling or tool use). These tools allow the model to call external code based on natural language input, effectively extending its capabilities beyond text generation.

Think of tools as plugins: they enable the model to interact with APIs, databases, or custom functions it wasn’t originally trained on.

For example, you could give a model access to your calendar, let it fetch real-time data from the web, or—in our case—allow it to structure user queries for a recipe search engine.

The Ingredient Categorization Tool

In this project, I defined a custom tool to extract and categorize ingredients from user requests. The function signature clearly specified the input format, enabling the LLM to:

• Parse free-form natural language to identify ingredients the user wants to include or avoid
• Return a structured payload with two lists: include_ingredients and exclude_ingredients
• Ensure the output was consistently formatted for downstream use in vector-based similarity search queries

This modular setup made the system much more flexible and accurate, bridging the gap between natural language and structured data queries.

def get_function_definition(self) -> dict:

       return {

           “type”: “function”,

           “function”: {

               “name”: “recipe_tool”,

               “description”: “Get a recipe based on the input and ingredient preferences. All ingredients must be specified in English.”,

               “parameters”: {

                   “type”: “object”,

                   “properties”: {

                       “ingredients_to_use”: {

                           “type”: “array”,

                           “items”: {“type”: “string”},

                           “description”: “List of ingredients that should be included in the recipe (the result have to be in English). e.g. [‘chicken’, ‘tomato’]”,

                       },

                       “ingredients_to_avoid”: {

                           “type”: “array”,

                           “items”: {“type”: “string”},

                           “description”: “List of ingredients that should not be included in the recipe (the result have to be in English). e.g. [‘beef’, ‘pork’]”,

                       },

                   },

                   “required”: [“ingredients_to_use”, “ingredients_to_avoid”],

                   “additionalProperties”: False,

               },

               “strict”: True,

           },

       }

The Search Algorithm: Finding the Perfect Recipe Match

Solving the Language Problem

One major challenge was handling multilingual input. While specialized models like bigscience/bloom-560m would have been ideal, I opted for a faster solution using prompt engineering to standardize ingredient lists in English.

I used two key techniques to achieve this:

• Emphasis / Highlighting – I used delimiters to clearly signal when an action was required.
• Few-shot prompting – I provided examples of the desired output to guide the LLM’s behavior.

The Recipe Search Process

My search algorithm followed these steps:

1. Convert desired ingredients into vector embeddings
2. Perform similarity searches in the vector database
3. Retrieve extra results to ensure good coverage
4. Filter out recipes containing unwanted ingredients
5. Select the highest-scoring recipe from the filtered results

While I could have implemented more complex reranking algorithms, the simple approach delivered excellent results within our timeframe.

Making Food Look Good: AI Image Generation

Selecting an Image Generation Model

Since I was already using OpenAI’s API, DALL-E 3 was the natural choice for generating appetizing recipe images.

The Art of Prompt Engineering

Creating effective image prompts proved interesting:

• Using only recipe titles sometimes produced irrelevant images (imagine what “Grandma’s Secret” might generate!)
• Including ingredients and preparation steps actually made results worse
• A refined prompt focusing on the title but with specific food-related guidance produced the most appealing images

What I Learned About AI Engineering

Finishing this project taught me several key lessons:

• The importance of making informed architectural decisions. A poor architectural choice can be the difference between a good solution and a bad one.
  
• Knowing when to pivot if a technical approach isn’t working. A great example of this was when I had to switch vector databases because my initial approach wasn’t getting the results I needed.
  
• Understanding that complex problems often have multiple valid solutions. That’s why it’s essential to constantly evaluate your approach. As you code, you get a deeper understanding of the problem, and sometimes that means rethinking your initial decisions.
  
• The value of having a diverse technical toolkit. Being familiar with different tools and technologies helps you choose the right solution for the problem at hand—and avoid getting stuck in a particular mindset or bias.
  
• And maybe most importantly: I learned that successful AI engineering requires both deep technical knowledge and creative problem-solving. You need to know when to use advanced techniques and when a simple solution is actually the best one.

Wrapping Up

This project demonstrated how AI engineers must blend various disciplines—from data processing and embedding to language models and image generation—to create cohesive, functional systems. The experience gave me valuable insights into making architectural decisions and understanding when to take different approaches.

A special thanks to everyone at BEON.tech involved in this pioneering program, especially Luis Arboleda for his excellent instruction throughout the course.

---

Are you looking to hire software engineers specialized in AI? At BEON.tech, we focus on sourcing and equipping tech professionals with the right mindset. You can schedule a call with us here.

And if you’re an AI enthusiast looking to boost your career, check out our open positions!