Michael Yuan

Your school district needs you! In this series of liveProjects, you’ll assist them by developing a custom chatbot for teaching students chemistry based on Meta AI’s Llama large language model. To do this, you’ll utilize open-source tools, including WasmEdge, LlamaEdge, Gaia, Git, Qdrant, Python, and UnSloth. Your AI application will need to run with very low resources—it needs to work on the school’s outdated computers—and be equipped with an intuitive user interface. Once you’ve developed your foundation, you’ll supplement it with a chemistry-specific knowledge base to ensure it can’t hallucinate! You will also fine-tune the model to make it work better with agents in the ecosystem while staying safe!

In order for the Llama-based chatbot app to answer chemistry questions reliably and without hallucination, you need to ground and supplement it with facts and knowledge. That’s why your local school district has tasked you with using RAG (Retrieval Augmented Generation) to help improve the capabilities of the chemistry chatbot app. RAG allows an LLM to search a knowledge base to help answer questions, avoiding unfortunate hallucinations. You’ll create a vector database for chemistry textbooks as the knowledge base, establish an RAG API server for the chatbot, and then deploy your new bot to both the web and Discord.

Your local school district has an LLM chatbot specialized in chemistry. But it sometimes answers questions entirely unrelated to chemistry! To improve the safety of this LLM application, you are asked to come up with a new LLM that would classify student questions and return machine-readable (JSON) messages to the application frontend so that the application can decide whether to answer this question. To accomplish that, you need fine-tuning to "teach" the model how to classify questions through many examples, which themselves are generated by a Llama-based LLM, and to always respond with JSON.

In this liveProject, you’ll take on the role of a full-stack developer working for a school district. Your district wants to further student learning by developing its own large language model (LLM) applications to assist students, parents, and teachers. Your goal is to develop an MVP of this by creating a chatbot that can answer questions and engage in follow-up conversations. You’ll utilize the open source Llama LLM from Meta AI to do this. Your model will need to run with very low resources—it needs to work on the school’s outdated computers—and be equipped with an intuitive user interface. Let’s get started!

Congratulations! You’re the new developer at UMET Inc. UMET is a successful U.S.-based e-commerce startup that lets social media influencers offer time-limited deals. It is crucial that the UMET web app can quickly scale up to handle large spikes of traffic while remaining nimble to orchestrate those deals with influencers. When UMET was started, it was built on a classic 3-tier stack with a web server, a Java application server, and a relational database. However, as UMET’s business grows, its monolithic architecture makes it difficult to scale and add or change features. The microservice pattern promises to support adding, removing and scaling service components on-demand to address fast-moving business requirements.

You’ve been tasked with transitioning its backend technology stack to microservices. You’ll create server-side WebAssembly (Wasm) applications using Rust and securely run them in portable WasmEdge runtime containers. Avoiding the pitfalls of heavyweight microservices, you’ll use the Rust Tokio and hyper crates to create a minimally viable HTTP web service, then you’ll enhance the application by creating a new microservice that depends on the previously created microservice. You’ll also use Docker Compose to manage multiple Wasm and Linux containers in a single application.

To enable your new interdependent microservices to integrate with existing order systems, you’ll build a microservice in Rust that can read and save data from UMET’s MySQL relational databases. You’ll reduce the overhead of managing the new microservices—including those built by other UMET teams as a result of the successful template you’ve created—by refactoring them to work with the Distributed Application Runtime (Dapr) framework, reducing complexity and, ultimately, overhead costs. When you’re finished, you’ll have the skills and knowledge to create lightweight, fully featured, highly performant microservices using Rust, Wasm, Docker, and Dapr.

UMET Inc. is growing! To support its increasingly complex features and services, the CTO has decided to refactor its backend technology stack, and the dev team has chosen the memory-safe, high-performance Rust programming language for this important investment in the company’s future. As a new developer at UMET, your task is to build proof-of-concept (PoC) Rust applications using Cargo or Docker tools, then securely run the applications in portable WasmEdge runtime containers to validate that the new backend stack meets all the necessary requirements. When you’re done, you’ll have mastered Rust basics for application development, including working with strings, managing complex data structures, and creating an HTTP web server.

UMET Inc.’s mission to modernize its software infrastructure has been a great success. The e-commerce company now uses Rust microservices that run in lightweight Wasm containers so that they can be deployed anywhere in the cloud. However, as more microservices are created, the overhead for managing them is becoming a problem. Using the Distributed Application Runtime (Dapr) sidecar, a commonly used design pattern, you’ll create a proof of concept (PoC) that demonstrates the pattern’s benefits, including reducing the complexity of connecting multiple microservices and infrastructure services (e.g. databases and web proxies). When you’re finished, you’ll have refactored UMET’s microservices to work with Dapr, reducing the overhead required to manage them.

To support its rapid growth, e-commerce company UMET Inc. relies on lightweight, interdependent, cloud-native microservices written in Rust that can compute sales tax rates and e-commerce order totals. As a developer at UMET, it’s up to you to integrate these microservices with existing order systems. To do that, you’ll need to turn the order total microservice into a database-backed stateful service. You’ll build and test the microservice in Docker and model the application data into relational database records. You’ll connect the microservice application to a MySQL database server, and you’ll use Docker to compose and manage all components of the microservice. When you’re done, you’ll have built an order management microservice in Rust that can read and save data from UMET’s MySQL relational databases and later serve as a template for other UMET microservices.

UMET Inc. is off to a great start in its efforts to refactor its backend to a modern technology stack using the popular, high-performance Rust programming language. As a new developer for the e-commerce platform, your task is to create a microservice for calculating order totals that depends on another microservice that looks up sales tax rates. Using HTML and JavaScript, you’ll create a web user interface for the microservices so that UMET product managers can test them in a browser. You’ll build and test your new application using Rust reqwest and Serde crates to make web service calls and also use Docker Compose to manage multiple Wasm and Linux containers in a single application. When you’re finished, you’ll have firsthand experience using WasmEdge command-line interface (CLI) tools to build a cloud-native application with interdependent microservices.

You’re a new developer at UMET Inc., an e-commerce platform that’s modernizing its backend technology stack with Rust. Your task is to create a simple HTTP service that looks up sales tax rates for U.S. ZIP codes and then deploy it in a lightweight container. To build the service, you’ll use Rust Tokio and hyper crates. You’ll compile, run, and test it in a lightweight WasmEdge container and use GitHub Actions to automatically test and validate any changes that you make. When you’re finished, you’ll have hands-on experience building, updating, and testing a minimally viable microservice using Rust and WebAssembly.