Michael Yuan

Socratic liveProjects pair you with an AI tutor to help you learn by doing, in real time.

You are an IT engineer at a midsize company where AI adoption is growing rapidly. But as the cloud AI bill climbs and confidential information leaves the company through API calls, management asks you to bring everyday AI work in-house. Across these three liveProjects, you’ll build a private local AI stack from the ground up: research open-weight models, run Google’s Gemma 4 on ordinary hardware with Docker Model Runner, and deploy a ChatGPT-style chatbot for coworkers. You’ll then connect the open-source pi agent to your local model so it can research proprietary documents and write code, before extending your agents with vision, exploring a fine-tuned MedGemma specialist model, and setting up hybrid inference that keeps routine work local while sending more demanding tasks to the cloud. By the end, you’ll have a working on-prem AI setup that runs on a typical laptop with 8–16 GB of memory.

Socratic liveProjects pair you with an AI tutor to help you learn by doing, in real time.

In this liveProject, you’ll take the company’s local AI rollout to the next level by giving its agents the ability to work with images as well as text. You’ll enhance prebuilt agents to process site photos, printed notices, and whiteboard sketches, turning visual information into useful answers and working web pages. You’ll also explore how fine-tuned open-weight models can be adapted for specialized business knowledge, and how local and cloud models can work together in a hybrid setup. By the end, you’ll have a practical path for combining private, specialized local AI with cloud models when additional capabilities are needed.

Socratic liveProjects pair you with an AI tutor to help you learn by doing, in real time.

In this liveProject, you’ll help your company’s local-AI rollout by moving beyond chatbots and putting your private AI model to work as an agent. You’ll connect the open-source coding agent pi to the local Gemma 4 model from the previous project through Docker Model Runner’s inference API. You’ll then use the agent for two practical tasks: researching a folder of company documents and answering questions with citations to its sources, and generating a self-contained web page based on the same documents. Along the way, you’ll see how local models can support autonomous research and coding while keeping company data on-premises.

Socratic liveProjects pair you with an AI tutor to help you learn by doing, in real time.

In this liveProject, you’ll take on the role of an IT engineer helping a midsize company reduce its dependence on costly cloud AI services and keep sensitive data in-house. Your goal is to build a proof-of-concept private alternative to ChatGPT using open-weight models running on local hardware. You’ll survey models and hardware options, set up the cross-platform Docker Model Runner, and run Google’s Gemma 4 E4B model on your own computer. You’ll first interact with the model from the command line, then deploy it through Open WebUI to create a browser-based chatbot that can be demonstrated to management and made available to non-technical colleagues.

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.