AI-Powered Personalized Recipe Recommendation Engine

Author: Regis Benoit Brice Nde Tene

Status: UNVERIFIED (Score: 0/100)

Duration: 1 Month Capstone

Executive Summary

This project develops an intelligent recipe recommendation system using Generative AI and Retrieval Augmented Generation. It leverages user preferences and dietary restrictions to provide personalized recipe suggestions, integrating with a vector database for efficient recipe retrieval and Langchain for AI orchestration. The system exposes its functionality through a REST API built with Node.js, and the user interface is implemented using React.

Key Skills

Project Execution Log

Stage 1: Design and Implement Vector Database for Recipes

This stage successfully established the core vector database for the recipe recommendation engine. By integrating `ChromaDB` and a `sentence-transformers` embedding model, we enabled semantic search capabilities, a crucial component for personalized and context-aware recipe suggestions. The database is now ready to be queried by the RAG system to retrieve relevant recipes.

Deliverables

  • [x] `vector_db_schema.json` (or equivalent configuration file/DDL for the chosen vector database) detailing the index structure and metadata fields.
  • [x] Python script (`ingest_recipes_to_vector_db.py`) responsible for processing raw recipe data, generating embeddings, and ingesting them into the vector database.
  • [x] Python script (`test_vector_search.py`) demonstrating how to perform semantic similarity queries against the populated vector database and retrieve relevant recipes.
  • [x] Documentation describing the chosen vector database setup, the schema used for recipe storage, and instructions for basic data ingestion and query operations.

Stage 2: Develop RAG Pipeline with Langchain and GenAI

This stage successfully established the core intelligence of the recipe recommendation engine by developing a Retrieval Augmented Generation (RAG) pipeline with Langchain. We integrated a GenAI model with our vector database, enabling context-aware recipe recommendations. This ensures that generated recipes are personalized, accurate, and grounded in our specific data, significantly reducing the risk of irrelevant or incorrect suggestions.

Deliverables

  • [x] `rag_pipeline.py`: A Python script containing the complete Langchain-based RAG pipeline implementation, including retrieval and generation logic.
  • [x] `test_rag_pipeline.py`: A set of unit and integration tests to validate the RAG pipeline's functionality, including test cases for various user queries and dietary restrictions.
  • [x] `rag_architecture_diagram.md`: A markdown document describing the RAG pipeline's architecture, including components, data flow, and configuration details.

Stage 3: Build REST API with Node.js for Recommendation Service

This stage focused on building the intermediary REST API using Node.js and Express. We established the server, defined the primary recommendation endpoint, and implemented the crucial integration logic to communicate with the AI recommendation engine. Key aspects like request parsing, error handling, and environment configuration were addressed, resulting in a robust API ready to bridge the gap between the frontend and the AI backend.

Deliverables

  • [x] `server.js` or `app.js` file containing the Express application setup and route definitions.
  • [x] Implementation of API endpoints (e.g., `/api/recommendations`, `/api/preferences`) handling request/response logic and AI backend integration.
  • [x] API documentation (e.g., in Markdown or OpenAPI specification format) detailing available endpoints, request bodies, and response structures.
  • [x] A Postman collection or a set of `curl` commands for testing all primary API endpoints.

Stage 4: Create React-based User Interface for Recipe Exploration

This stage successfully established the user-facing part of the recipe recommendation system by building a React application. It focused on component-based UI development, API integration with `axios`, and client-side routing with `react-router-dom`, resulting in an interactive and responsive interface for recipe exploration.

Deliverables

  • [x] `src/components/` directory containing reusable React UI components (e.g., `RecommendationForm.js`, `RecipeCard.js`, `RecipeDetailView.js`).
  • [x] `src/pages/` directory with main application views (e.g., `HomePage.js`, `RecipeDetailPage.js`).
  • [x] `src/App.js` integrating React Router for navigation and overall application layout.
  • [x] An updated `package.json` file including all necessary React-related client-side dependencies.

Stage 5: Implement Observability and Monitoring for AI System

This stage focused on establishing robust observability and monitoring for the AI-powered recipe recommendation engine. By instrumenting the Node.js API, Python AI/RAG services, and integrating with tools like Prometheus and Grafana, we gained critical insights into system performance, health, and AI model behavior. This framework ensures proactive issue detection, efficient troubleshooting, and continuous improvement of the recommendation system's reliability and user experience.

Deliverables

  • [x] Detailed **Observability Configuration Files** for logging, metrics, and tracing across Node.js and Python services.
  • [x] Set of **Monitoring Dashboards** (e.g., Grafana dashboards) providing real-time system health and AI performance visualizations.
  • [x] **Alerting Rules Configuration** documenting critical alerts and notification channels.
  • [x] **Documentation** outlining the observability architecture, how to access logs/metrics/traces, and basic troubleshooting guides.

Stage 6: Troubleshoot and Optimize Recommendation Performance

This stage focused on diagnosing and resolving performance and recommendation quality issues in the AI-powered recipe engine. Key actions involved implementing robust monitoring, analyzing logs, refining the RAG pipeline's retrieval and generation components, and optimizing the Node.js API for responsiveness. The outcome is a more accurate and efficient recommendation system, ready for a better user experience.

Deliverables

  • [x] Performance Optimization Report, detailing baseline metrics, identified bottlenecks, implemented solutions, and improved performance indicators.
  • [x] Updated API and RAG Pipeline Code, with comments and documentation reflecting the optimizations made.
  • [x] Test Cases and Results, demonstrating the improved recommendation relevance and system performance.
  • [x] Revised Monitoring Configuration/Dashboard Snapshots, if any new metrics or alerts were introduced during optimization.