Some financial analysts worry that artificial intelligence may not justify the massive investments being made in the field. While I understand their concerns, I see things differently. I\u2019m neither an AI Boomer nor an AI Doomer\u200a\u2014\u200aI believe AI has the potential to drive innovation, enhance productivity, and deliver measurable business outcomes.<\/p>\n
In my last article, I explored how Large Language Models (LLMs) can be used to structure unstructured data. This time, I want to go a step further: demonstrating how the outcome of structuring data with LLMs can serve as the foundation for building intelligent applications<\/strong>. Thus showing how to integrate AI in a bigger\u00a0picture.<\/p>\n In this article, I\u2019ll share how I used a modern stack to fast-track the development and deployment of Baker\u200a\u2014\u200aa smart app which is the result of transforming a raw recipes dataset into an easy to use solution. This journey highlights more than just technical implementation; it showcases how AI can address practical challenges and deliver tangible value in real-world scenarios.<\/p>\n In The (lesser-known) rising application of LLMs<\/strong><\/a>, I mentioned that I needed a recipes dataset to work on a personal project. Now, it\u2019s time to reveal that\u00a0project.<\/p>\n Managing food has always been a challenge for me. I struggle to find inspiration for meals, and as a result, I often let ingredients go to waste\u200a\u2014\u200asomething I\u2019ve wanted to change for a long time. That\u2019s why I set out to create a recipe recommender system that helps me (and others) use up ingredients before they go stale. The solution? Baker<\/strong>, my prototype for tackling this issue. This project reflects my passion for leveraging AI to tackle everyday challenges like food\u00a0waste<\/strong>.<\/p>\n Baker is an open-source web application in its early stages, built almost entirely in Python. The app takes a list of ingredients and their quantities\u200a\u2014\u200amimicking what you might find in your fridge and pantry\u200a\u2014\u200aand suggests recipes you can prepare using those ingredients. It\u2019s designed to simplify meal preparation while encouraging smarter, more sustainable food choices. You can try the app yourself\u00a0here:<\/p>\n \u21d2 mixit-baker.streamlit.app<\/a><\/p>\n However, you might want to read the remaining of the article first. In one of the next sections<\/a>\u00a0, I\u2019ll walk you through a demo of the application.<\/p>\n After the initial parsing of the dataset, I became busy with other duties and set this side project aside for months \ud83d\ude09. But technology evolves quickly. When I finally returned to it, a series of newer models, techniques, and tools had emerged or matured, providing an opportunity to revisit and enhance the\u00a0project.<\/p>\n The first step was to revisit my earlier work on data extraction and update the results<\/a>. In my previous iteration, I had used MistralAI\u2019s open-mixtral-8x7b<\/strong>, which had since been deprecated. This time, I switched to the newer and more advanced GPT-4o<\/strong>, and the results were remarkable.<\/p>\n To put the improvement into perspective:<\/p>\n This milestone reflects how quickly AI capabilities improve. Just months ago, LLMs often struggled to output valid JSON reliably. This iteration demonstrated not only better results but also how adopting newer tools can yield substantial gains.<\/p>\n Even with improved extraction, the raw data required significant post-processing. Recipes featured inconsistent units\u200a\u2014\u200agrams, teaspoons, cups, and more\u200a\u2014\u200amaking comparisons and recommendations challenging. To address this, I adopted a systematic approach:<\/p>\n This normalization step was essential for enabling accurate ingredient filtering and powering the recipe recommendation engine. It also underscored a critical point: AI outputs must be contextually meaningful for their intended application, not just technically correct.<\/p>\n With the data cleaned, standardized, and ready for use, the next step was to start leveraging the data which I did by building the engine logic and wrapping it in a web\u00a0app<\/a>.<\/p>\n Throughout Baker\u2019s development, I embraced a quick prototyping philosophy. The goal was less building an app from day one but rather to explore tools and techniques, test ideas and gather feedback.<\/p>\n From Notebooks to a POC\u00a0app:<\/strong><\/p>\n The way I built my data pipeline and the web app using AI illustrate the quick prototyping philosophy.<\/p>\n By adopting this approach, I was able to build a working MVP in days rather than weeks or\u00a0months.<\/p>\n Open-Source:<\/strong><\/p>\n A marker of Baker<\/strong> is its open-source nature<\/strong>. By sharing the project on GitHub, I hope\u00a0to:<\/p>\n Open-sourcing makes it easier for others to reproduce results, contribute improvements, and exchange ideas. Collaboration not only strengthens Baker<\/strong> but also fosters collective innovation.<\/p>\n Free Deployment: Accessible and Lightweight<\/strong><\/p>\n To make Baker<\/strong> accessible, I deployed it using free-tier services:<\/p>\n These platforms allowed me to deploy quickly and experiment without the financial or technical barriers of traditional hosting solutions. This deployment strategy highlights how modern tools make it possible to turn creative ideas into accessible applications at little to no\u00a0cost.<\/p>\n In this section, I\u2019ll share some implementation details of Baker. Again it is open-source so I invite my technical readers to go check the code on GitHub. Some readers might want to jump to the next\u00a0section<\/a>.<\/p>\n The application is minimalist with a simple 3 tier architecture and is built almost entirely in\u00a0Python.<\/p>\n It is made of the following components:<\/p>\n The backend is initialized in app.py, where FastAPI endpoints are defined. For instance:<\/p>\n The \/recipes endpoint accepts a list of ingredients and a serving size then delegates the processing to the\u00a0engine.<\/p>\n The heart of the application resides in core.py within the engine directory. It manages database connections and query pipelines. Below is an example of the find_recipes function:<\/p>\n The core logic of Baker<\/strong> resides in the find_recipes function.<\/p>\n This function creates a MongoDB aggregation pipeline thanks to monggregate. This aggregation pipeline includes several\u00a0steps.<\/p>\n The first steps are generated by the include_normalization_steps function that is going to dynamically update the quantities of the ingredients in the database to ensure we are comparing apples to apples. This is done by updating the ingredients quantities in the database to the user desired\u00a0serving.<\/p>\n Then the actual matching logic is created by the generate_match_query function. Here we ensure, that the recipes don\u2019t require more than what the user have for the ingredients concerned.<\/p>\n Finally a projection filters out the fields that we don\u2019t need to\u00a0return.<\/p>\n Baker<\/strong> helps you discover a better fate for your ingredients by finding recipes that match what you already have at\u00a0home.<\/p>\n The app features a simple form-based interface. Enter the ingredients you have, specify their quantities, and select the unit of measurement from the available options.<\/p>\n In the example above, I\u2019m searching for a recipe for two servings<\/strong> to use up 4 tomatoes and 2 carrots that have been sitting in my kitchen for a bit too\u00a0long.<\/p>\n Baker<\/strong> found two recipes! Clicking on a recipe lets you view the full\u00a0details.<\/p>\n Baker<\/strong> adapts the quantities in the recipe to match the serving size you\u2019ve set. For example, if you adjust the serving size from two to four people, the app recalculates the ingredient quantities accordingly.<\/p>\n Updating the serving size may also change the recipes that appear. Baker<\/strong> ensures that the suggested recipes match not only the serving size but also the ingredients and quantities you have on hand. For instance, if you only have 4 tomatoes and 2 carrots for two people, Baker<\/strong> will avoid recommending recipes that require 4 tomatoes and 4\u00a0carrots.<\/p>\n Baker is a side project developed quickly and pragmatically, a functional prototype rather than a production-ready application.<\/p>\n However, I\u2019d love to see it grow into something more impactful.<\/p>\n There are several areas where the app can expand, both in functionality and sophistication. To move forward, let\u2019s address its current limitations and explore possible enhancements.<\/p>\n Baker\u2019s recipes originate from Public Domain Recipes<\/a>, an open-source database of recipes. While this is an amazing project, the number of available recipes is limited. As a result, Baker<\/strong> only knows 360 recipes for now. To put this into perspective, some dedicated recipe websites claim to have tens of thousands recipes.<\/p>\n To scale, I\u2019ll need to identify additional data sources for\u00a0recipes.<\/p>\n At the moment, data ingestion<\/strong> is handled through Jupyter Notebooks. One of the main technical priorities is to transform these notebooks into robust Python scripts, integrate them into an admin section of Baker<\/strong>, or even spin them off into a dedicated app.<\/p>\n Additionally, I am convinced that there\u2019s room for improving the parsing process performed by the LLMs to ensure greater consistency and accuracy.<\/p>\n Currently, recipes are searched by ingredient names through exact string matching. For example, searching for \u201ctomato\u201d will not retrieve recipes that mention \u201ctomatoes.\u201d This can be addressed by implementing a semantic search approach using vector databases<\/a>. With semantic search<\/strong>, variations of ingredient names\u200a\u2014\u200awhether due to pluralization, regional differences, or translation\u200a\u2014\u200acan be dynamically mapped to the same\u00a0concept.<\/p>\n Moreover, semantic search would allow users to search in their native language, further broadening accessibility.<\/p>\n I also want to introduce greater flexibility in the search functionality<\/strong>. For example, if a user searches for recipes with tomatoes, carrots, and bananas but no such combination exists in the database, the search should still return recipes with subsets of the entered ingredients (e.g., tomatoes and carrots, tomatoes and bananas, or carrots and bananas).<\/p>\n From a feature standpoint, this is my top priority.<\/p>\n While the above are the main focus areas, there are plenty of other topics I\u2019d like to\u00a0address:<\/p>\n I hope you\u2019ve enjoyed reading this journey of turning ideas into reality. If you did, consider supporting me on Buy Me a Coffee<\/a> to help fund future developments. Now, let\u2019s summarize the key takeaways.<\/p>\n A few months ago, I wrote an article about how using LLMs for data structuration and extraction<\/strong> was a promising use case powered by the new Generative AI wave. In this follow-up, I\u2019ve taken the concept further by demonstrating a tangible outcome: using a LLM-generated dataset to power a data-centric smart app,\u00a0Baker<\/strong>.<\/p>\n Along the way, I aimed to show how this process has become more accessible with modern tools like Streamlit, FastAPI, Streamlit Cloud, Koyeb, and Cursor.<\/strong> If you want a deep dive on the tools I used, let me know in the comments.<\/p>\n These tools provide the flexibility and accessibility needed to focus on solving real problems rather than being overwhelmed by the complexity of managing multiple aspects\u200a\u2014\u200adata pipelines, backend logic, frontend interfaces, CI\/CD workflows, cloud deployments, testing, and the intricacies of various programming languages.<\/p>\n But this project isn\u2019t just about recipes\u200a\u2014\u200ait\u2019s about unlocking the potential of unstructured data to solve real-world problems. For instance, the same approach used in Baker<\/strong> could be applied to create a personalized learning platform. By structuring educational content, such as lecture transcripts or articles, into accessible formats and building a recommendation engine, one could help users discover relevant learning materials based on their goals or interests.<\/p>\n Whether for education, product recommendations, or knowledge management, the principles and tools I\u2019ve shared here can inspire countless applications.<\/p>\n As we step into the new year, I encourage you to reflect on your own untapped datasets and ideas. What could you build with the tools and knowledge shared here? With small steps, quick iterations, and a collaborative mindset, you, too, can create innovative solutions<\/strong> that make a difference.<\/p>\n Here\u2019s to building a smarter, more data-driven future\u200a\u2014\u200atogether.<\/p>\n Transforming Data into Solutions: Building a Smart App with Python and AI<\/a> was originally published in Towards Data Science<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>\n<\/div>\nBaker: Your Cooking\u00a0Muse<\/h3>\n
From Idea to POC: Accelerated Development with AI and Modern\u00a0Tools<\/h3>\n
Revisiting Data Extraction with\u00a0GPT-4o<\/strong><\/h4>\n
\n
Post-Processing Challenges<\/strong><\/h4>\n
\n
Building the Engine and Web Application<\/strong><\/h4>\n
Quick Prototyping<\/strong><\/h4>\n
\n
\n
\n
Behind the Scenes: The Technology Powering\u00a0Baker<\/strong><\/h3>\n
![\"An](\"https:\/\/i0.wp.com\/cdn-images-1.medium.com\/max\/848\/1%2AWb8bqb8ClDw7DDrYlQO3JQ.png?ssl=1\")
\n
Backend Setup<\/h4>\n
from fastapi import FastAPI
from baker.engine.core import find_recipes
from baker.models.ingredient import Ingredient
app = FastAPI()
@app.get(\"\/\")
def welcome():
return {\"message\": \"Welcome to the Baker API!\"}
@app.post(\"\/recipes\")
def _find_recipes(ingredients: list[Ingredient], serving_size: int = 1) -> list[dict]:
return find_recipes(ingredients, serving_size)<\/pre>\nRecipe Engine\u00a0Logic<\/h4>\n
# Imports and the get_recipes_collection function are not included
def find_recipes(ingredients, serving_size=1):
# Get the recipes collection
recipes = get_recipes_collection()
# Create the pipeline
pipeline = Pipeline()
pipeline = include_normalization_steps(pipeline, serving_size)
query = generate_match_query(ingredients, serving_size)
print(query)
pipeline.match(query=query).project(
include=[
\"id\",
\"title\",
\"preparation_time\",
\"cooking_time\",
\"original_serving_size\",
\"serving_size\",
\"ingredients\",
\"steps\",
],
exclude=\"_id\",
)
# Find the recipes
result = recipes.aggregate(pipeline.export()).to_list(length=None)
return result
def generate_match_query(ingredients: list[Ingredient], serving_size: int = 1) -> dict:
\"\"\"Generate the match query.\"\"\"
operands = []
for ingredient in ingredients:
operand = {
\"ingredients.name\": ingredient.name,
\"ingredients.unit\": ingredient.unit,
\"ingredients.quantity\": {\"$gte\": ingredient.quantity \/ serving_size},
}
operands.append(operand)
query = {\"$and\": operands}
return query
def include_normalization_steps(pipeline: Pipeline, serving_size: int = 1):
\"\"\"Adds steps in a pipeline to normalize the ingredients quantity in the db
The steps below normalize the quantities of the ingredients in the recipes in the DB by the recipe serving size.
\"\"\"
# Unwind the ingredients
pipeline.unwind(path=\"$ingredients\")
pipeline.add_fields({\"original_serving_size\": \"$serving_size\"})
# Add the normalized quantity
pipeline.add_fields(
{
# \"orignal_serving_size\": \"$serving_size\",
\"serving_size\": serving_size,
\"ingredients.quantity\": S.multiply(
S.field(\"ingredients.quantity\"),
S.divide(serving_size, S.max([S.field(\"serving_size\"), 1])),
),
}
)
# Group the results
pipeline.group(
by=\"_id\",
query={
\"id\": {\"$first\": \"$id\"},
\"title\": {\"$first\": \"$title\"},
\"original_serving_size\": {\"$first\": \"$original_serving_size\"},
\"serving_size\": {\"$first\": \"$serving_size\"},
\"preparation_time\": {\"$first\": \"$preparation_time\"},
\"cooking_time\": {\"$first\": \"$cooking_time\"},
# \"directions_source_text\": {\"$first\": \"$directions_source_text\"},
\"ingredients\": {\"$addToSet\": \"$ingredients\"},
\"steps\": {\"$first\": \"$steps\"},
},
)
return pipeline<\/pre>\nUser Guide: Discovering Recipes with Baker in a Few\u00a0Clicks<\/h3>\n
![\"A](\"https:\/\/i0.wp.com\/cdn-images-1.medium.com\/max\/887\/1%2ANOR7Ivr0WvTTIq3fuKsClg.png?ssl=1\")
![\"A](\"https:\/\/i0.wp.com\/cdn-images-1.medium.com\/max\/855\/1%2Atb_d9HrGgftSmTzcKvnYZw.png?ssl=1\")
The Road Ahead: Scaling Baker for Broader\u00a0Impact<\/h3>\n
1\u200a\u2014\u200aGrowing the Recipe\u00a0Database<\/h3>\n
2\u200a\u2014\u200aImproving the Data Ingestion Pipeline<\/h3>\n
3\u200a\u2014\u200aAdding Semantic Search & Flexibility<\/h3>\n
Other Enhancements to\u00a0Consider<\/h3>\n
\n
Conclusion<\/h3>\n
<\/p>\n
\n