Progress Report

Stage I Report (Weeks 1–3): Research & Feasibility

During Weeks 1–3, the team focused on research and experimentation. We explored several open-source large language models available through Ollama, including LLaMA, Qwen, Gemma, and Phi. These models were evaluated based on recommendation-style prompting, response quality, and performance.

Initially, we developed a prototype using Java and Spring Boot, where prompts were sent to Ollama and responses were retrieved via REST APIs. This phase confirmed that local LLM inference was feasible for our project goals. After discussions with our mentor, Lucas, we decided to transition the backend to Go due to its strong concurrency support, performance efficiency, and simplicity for backend service development. As a result, the Java/Spring Boot prototype was replaced with a Go-based implementation.

Stage II Report (Weeks 4–6): Backend Architecture & Core Features

In this stage, we designed and implemented the Go-based backend architecture. The system was modularized into clear components, including:

LLM orchestration
Vector-based recommendation pipeline
Catalog ingestion for movies and shopping data
SQLite database storage

We implemented REST endpoints to send prompts to Ollama models and return structured recommendation results. In Week 6, we conducted our first project demo, demonstrating an end-to-end LLM-based recommendation pipeline. Feedback from the TA was incorporated to improve API consistency and code organization.

Stage III Report (Weeks 7–10): Advanced Features & Comparison Pipelines

During this phase, we expanded the system to support batch processing, multiple models, and vector-based recommendations alongside LLM-based approaches. This allowed us to directly compare:

LLM-generated recommendations
Vector similarity-based recommendations

We added configurable timeouts, controlled concurrency, and cancellation mechanisms to prevent system hangs when running multiple models. A more interactive frontend was developed using React and Tailwind, allowing users to select models, compare outputs, and visualize results. A major demo was conducted in Week 10, showcasing batch execution and model comparison functionality.

Stage IV Report (Weeks 11–16): Polishing, Evaluation & Final Demo

In the final stage, we focused on system stability, documentation, and evaluation. The database schema was refined, CSV export functionality for runs and metrics was added, and backend API endpoints were finalized. The frontend UI/UX was polished to clearly display recommendations, metrics, and comparisons.

Final testing was conducted across multiple models to ensure reliable performance under different workloads. The final project demo in Week 16 presented the complete AI Recommendation Engine, demonstrating both movie and shopping recommendation workflows, and discussing architectural decisions, trade-offs, and lessons learned.

Weekly Meetings

Week 2

Discussed project scope and overall goals.
Researched Ollama and available open-source LLM models.
Held first TA meeting to confirm feasibility and expectations.
Planned initial prototype development using Java and Spring Boot.

Week 3

Continued researching different LLM models and prompt strategies.
Tested prompt-response behavior using Ollama.
Compared response quality and performance across models.
Decided to explore alternative backend technologies.

Week 4

Discussed feedback from client regarding backend choice.
Decided to transition backend from Java/Spring Boot to Go.
Planned Go backend architecture and module structure.
Assigned tasks for backend setup and API design.

Week 5

Implemented core Go backend structure.
Integrated Ollama with REST endpoints.
Began setting up database schema and data ingestion.
Integrated backend with a simple functional frontend
Integrated Vector recommendation logic
Tested basic prompt-to-response pipeline.

Week 6 – Meeting 1 (Pre-Demo)

Prepared demo workflow and test cases.
Reviewed system functionality and known limitations.
Verified backend endpoints and model responses.
Assigned demo responsibilities among team members.

Week 6 – Meeting 2 (Post-Demo)

Reviewed demo feedback from TA.
Identified improvements for modularity and scalability.
Discussed next steps for batch processing.
Updated task assignments based on feedback.

Week 7

Planned batch processing and multi-model execution.
Designed vector-based recommendation approach.
Discussed frontend requirements and technology stack.
Began initial frontend development planning.
Implemented batch processing logic in backend.
Continued work on vector similarity pipeline.
Refined database schema for recommendations.
Tested system with multiple models.

Week 9

Integrated vector and LLM pipelines.
Improved error handling and logging.
Continued frontend implementation.
Prepared materials for upcoming demo.

Week 10 – Meeting 1 (Pre-Demo)

Finalized demo features and comparison workflows.
Tested batch execution and model switching.
Reviewed UI functionality.
Resolved last-minute bugs.

Week 10 – Meeting 2 (Post-Demo)

Discussed demo feedback and performance observations.
Identified optimization opportunities.
Planned improvements for concurrency handling.
Updated roadmap for final phase.

Week 11

Improved concurrency control and timeout handling.
Added cancellation logic for long-running tasks.
Continued frontend UI/UX refinements.
Tested system stability under load.

Week 13

Worked on metrics collection and result evaluation.
Added export functionality for recommendations.
Refined API endpoints.
Reviewed documentation progress.

Week 15

Conducted final testing across multiple models.
Fixed remaining bugs and edge cases.
Polished frontend presentation.
Prepared for final demo.

TA Meetings