DEV Community: Eben

Building an AI Recipe App with Django and GroqCloud:Llama 3.1: My Journey with myChefAssist

Eben — Mon, 12 Aug 2024 01:32:15 +0000

Creating an AI-powered recipe app like myChefAssist has been full of technical challenges and learning. myChefAssist is meant to help users create recipes based on the ingredients they have, with AI making the experience more personal and interactive. In this post, I’ll share the technical details, challenges, and what I’ve learned along the way.

How It Works

Backend Setup:
myChefAssist is built using Django for the backend, with PostgreSQL as the database. The AI, powered by Llama 3.1 through GroqCloud, helps users by generating different recipe options based on their input.

Key Features:

Multiple Recipe Options: Users get several recipe options from the AI, based on their ingredients or preferences.
Ingredient Matching: After a recipe is chosen, the system checks the user’s available ingredients and adjusts the recipe accordingly.
Flexible Recipe Suggestions: If the user doesn’t have enough ingredients, the AI suggests a different recipe that fits what they have.

Challenges and Solutions

1. Getting AI Responses in JSON:
The AI had to return recipe data in a JSON format that matched Django’s models. This was important because the recipe data needed to be saved in the database.

Solution:

Clear JSON Structure: I defined a JSON structure that matched Django models, making sure all the necessary details like ingredients and steps were included.
Validation: I wrote Django commands to check the incoming JSON data to make sure it was correct before saving it to the database.

2. Handling Multiple Recipes:
The app needed to handle multiple recipes at once, which meant the API had to fetch and process several AI-generated recipes in one go.

Solution:

API Extension: I extended the API to handle multiple recipes, making sure each one was correctly formatted and saved to the database.
Optimized Database Transactions: I batched the database transactions to reduce the load and improve performance.

3. Managing User-Selected Recipes:
Once a user picks a recipe, the system needs to save it. This involved transforming the AI’s JSON response into a format that Django could use.

Solution:

Data Pipeline: I created a pipeline to convert the AI’s JSON into Django objects, handling errors to manage incomplete or incorrect data.
Persistent Storage: The selected recipe, with any user changes, is stored in the database for future use.

Overcoming Technical Hurdles

1. Limited System Resources:
My PC wasn’t powerful, so I had to work in safe mode, which made it hard to run PostgreSQL.

Solution:

Registry Tweaks: I tweaked the system’s registry settings to allow PostgreSQL to work in safe mode.
Optimized Workflow: I wrote scripts to make common tasks easier, reducing the system’s load and making work faster.

2. Lack of Documentation:
There weren’t many guides on integrating Django with GroqCloud for AI, so I had to figure out a lot on my own.

Solution:

Self-Documentation: I documented my process to help myself and others in the future.
Community Help: I reached out to the developer community for advice and shared what I learned.

What’s Next: Improving User Experience

The next step is to make the user experience better by letting the AI suggest different recipes if the user doesn’t have enough ingredients for the first choice. This will require both backend and frontend updates.

Lessons Learned

Break Tasks into Small Steps: Breaking down complex tasks into smaller ones makes them easier to manage.
Define Clear Data Structures: Creating a clear data structure early on helps avoid issues later.
Manage Resources Wisely: Optimizing your work environment, especially with limited resources, can improve productivity.

Building myChefAssist has been a tough but rewarding experience. I’ve learned a lot about AI integration, backend development, and solving problems with limited resources. I’m excited to keep working on the project.

If you’ve faced similar challenges or have tips on AI integration with Django, let’s connect and share ideas!

Building myChefAssist with AI: Lessons Learned and How to Avoid Pitfalls

Eben — Tue, 30 Jul 2024 06:54:43 +0000

When I embarked on creating an AI-powered chef assistant, I wanted to solve a real need instead of building another generic chatbot. The idea was simple yet practical: a web app that helps users prepare meals based on the ingredients they have.

The Concept

Users enter the dish they want to prepare. The app, leveraging AI, asks follow-up questions to refine the dish type. It then lists all required ingredients, allowing users to select which ones they have. If the user doesn't have enough ingredients, the app either suggests a different dish or tells them the minimal additional ingredients needed to make the original dish.

Starting the Backend

I began by outlining the basic features and setting up the backend. Using Django and PostgreSQL, I created the project, set up the database, and defined the models. The setup process for PostgreSQL was straightforward:

Install PostgreSQL: Download and install the latest version from the official PostgreSQL website.
Create a Database: Use the createdb command or pgAdmin to create a new database for the project.
Connect Django to PostgreSQL: Update Django's settings.py with the database credentials, ensuring the ENGINE is set to 'django.db.backends.postgresql'.

Choosing the Right AI Model

The real challenge was selecting an AI model to run locally on my PC. I opted for Llama 3.1, the latest model available. I started with the 8B version, considering my PC's capabilities. After downloading the model (4.7GB), I tested it with a simple "hi" query. The response time was painfully slow, and my PC became unresponsive.

After trying stablelm-zephyr, which promised to be lightweight, and facing similar issues, I moved on to other models like those available on Hugging Face. Still, the performance wasn't there. Finally, I switched to Llama 3.1 on GroqCloud, which provided fast responses in less than a second, saving the day.

Lessons Learned

Assess Hardware Capabilities: Ensure your hardware can handle the AI model you're planning to use. Overloading your system can lead to severe performance issues.
Start Small: Begin with lighter models and scale up as needed. This helps prevent unnecessary strain on your system.
Cloud Solutions: Sometimes, using cloud-based solutions like GroqCloud can save you time and resources.

Next Steps

The next step involves connecting user inputs to the AI model and storing the responses in the database. The data will be categorized and saved under columns like User Queries, Selected Ingredients, Suggested Recipes, and Missing Ingredients.

What AI challenges have you faced, and how did you overcome them? Share your experiences!

🚀 Exploring Django with React 🚀

Eben — Tue, 30 Jul 2024 05:26:03 +0000

Kicking off my series with Django and React! Combining Django’s backend with React’s frontend... Thinking of an AI-based project. Follow along as I share what I learn from this project.

What challenges have you faced using Django with React? Share your thoughts! 💬