Loading…
Browse by type
Tutorial reads
Tutorial posts on Yomu, summarised newest first.
- 615 posts
- 20 companies
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Tutorial posts
Developing NVIDIA Holoscan Applications with CLI, Skills, and AI Coding Agents
NVIDIA Holoscan is a platform for real-time AI applications at the edge, and HoloHub provides reference applications and components. This post describes an engineer-guided workflow in which a coding agent builds a separate Python endoscopic tool segmentation application from the existing MONAI model, sample video, and Holoscan patterns. The Holoscan CLI, invoked through ./holohub, exposes shared commands for scaffolding, running, modes, tests, and benchmarking, while development skills and documentation guide the agent through project-specific operations. The application connects video replay, preprocessing, TensorRT inference, segmentation postprocessing, telemetry, and HoloViz visualization, with visual, smoke, and benchmark modes; the post reports that the CLI-plus-skills-plus-docs/examples configuration produced a separate application in 40 minutes using 11M tokens, and concludes that this combination offered the lowest resource overhead among the compared configurations.
Designing effective Genie Agents from a single prompt
Generic agents may select the first relevant-looking revenue table rather than the finance-maintained source because they lack business context. Genie Agents address this by using a single prompt to assemble a domain-specific agent from governed Unity Catalog context, including structured data, documents, and files. The prompt identifies the desired outcome and relevant sources, while the agent can retrieve content from PDFs, Word documents, presentations, images, and tables under the requesting user’s permissions. The recommended process is to begin with one focused, repetitive job, test it against known questions or incidents, and expand only after measuring performance. Built-in benchmarks provide accuracy scores, while monitoring surfaces user questions and feedback that can reveal gaps in the curated context.
Post-Train NVIDIA Cosmos 3 Edge for On-Device Robot Control
Deploying large world models on robots is constrained by onboard memory and the control latency needed for continuous manipulation. The tutorial post-trains NVIDIA Cosmos 3 Edge, a 4B omni-model with a 2B NVIDIA Nemotron-based reasoner, into a DROID action policy using 76,000 successful teleoperated trajectories, then serves it through an OpenPI-compatible WebSocket server on Jetson Thor. The configuration predicts 32 future 8-dimensional joint-position actions at 15 Hz, while a receding-horizon loop executes a prefix and replans from fresh camera and robot-state observations. On an NVIDIA Jetson AGX Thor T5000, inference takes about 1.53 seconds per action chunk covering roughly 2.13 seconds of motion, and the policy reaches 22.9% success in closed-loop RoboLab evaluation; the source contrasts this with Cosmos 3 Nano’s 36.8%.
Building E-commerce AI Agents on MongoDB with CrewAI
A 34% year-over-year increase in consumers using generative AI for online shopping, especially among Gen Z and Millennials, is motivating e-commerce teams to adopt AI shopping agents. This tutorial demonstrates building a chat-based shopping assistant on MongoDB Atlas with CrewAI that supports zero-click buying from product discovery to post-purchase follow-up. The agent interprets natural-language queries, retrieves semantically relevant products via MongoDB Vector Search with Voyage AI embeddings using price and inventory pre-filters before similarity ranking, and uses Change Streams for atomic inventory checkout. Atlas Triggers enable proactive order notifications, while Atlas Stream Processing detects delivery patterns by monitoring updates in two-minute tumbling windows, writing confirmed signals to agent_triggers when at least 10 orders per carrier-region are delayed by 45 minutes. MongoDB consolidates operational data, semantic search, and event-driven capabilities into a single platform, reducing latency and complexity.
How to Build Passwordless Auth With Twilio Verify in Rust
Passwordless authentication replaces passwords with one-time codes delivered by SMS, and this tutorial builds a Rust app around that flow. The app uses Twilio Verify for OTP generation and validation, with GET and POST routes at "/" for collecting a phone number and at "/verify" for entering the received code. It sets up a Cargo project with Axum, Handlebars templates, sessions, dotenvy configuration, and the rustlio Twilio client, while environment variables hold the Account SID, Auth Token, and Verify Service SID. The implementation also serves HTML forms and static assets, with verification status rendered as a success or error message. Running cargo run starts the server on port 8080, where users can submit a number, receive an SMS, and see whether the verification code is valid.
How to Build Passwordless Auth With Twilio Verify in PHP
Passwordless authentication with PHP and Twilio Verify replaces password entry with a phone-based one-time passcode flow, intended to reduce password-related risk and simplify sign-in. The tutorial uses a Slim base project, Composer dependencies, Dotenv configuration, a Twilio Verify Service SID, and PHP session state to support the flow. Users submit a phone number through the root route; the server asks Twilio Verify to send an SMS OTP, redirects to /verify, and checks the submitted code through the verification endpoint. The example’s verification form restricts input to a six-digit numeric value, and the application reports whether verification succeeded or failed after testing locally with composer serve on port 8080.
How to Build Passwordless Auth With Twilio Verify in Go
The tutorial builds a passwordless authentication flow in Go that uses Twilio Verify to send and validate one-time passwords (OTPs) by SMS, avoiding the need for users to manage passwords. It defines a small net/http API with GET and POST handlers for "/" and "/verify": the first collects a mobile number and starts verification, while the second accepts the received code and displays the result. The setup covers Go 1.23 or later, module dependencies, dotenv configuration for the Twilio Account SID, Auth Token, and Verify Service SID, plus session handling for the phone number. The verification check calls Twilio's CreateVerificationCheck() and renders success or failure using templates; running go run main.go starts the server on port 8080 for testing.
Building Secure AI Agents with Microsoft Agent Framework and Auth0: Sending Email with Token Vault
An expense-reviewing AI agent required manual manager intervention to email employees about missing report data such as amounts, merchants, or justifications. To automate follow-ups safely, the agent uses Auth0 Token Vault to acquire and refresh Google OAuth tokens without storing credentials in the application database. The implementation configures Auth0 with offline access, My Account API permissions, and multi-resource refresh tokens to handle silent token retrieval across user sessions. Rather than exposing Gmail credentials to the underlying language model, the agent executes email actions via an internal backend endpoint that retrieves a short-lived access token, sends the email, and immediately discards the token.
Hello, Ireland! Sending SMS in Twilio’s Ireland Region
Twilio’s Ireland region, IE1, provides EU data residency for Programmable SMS, keeping personal data such as recipient phone numbers and message bodies in the EU through the supplier edge. Adopting it requires separate IE1 credentials and an IE1 Messaging Service, while US1 Messaging Services cannot be reused; SMS to and from +1 numbers, RCS, and WhatsApp are not currently supported. For API calls, the main code change is replacing api.twilio.com with api.dublin.ie1.twilio.com, while client SDK users switch the region parameter from us1 to ie1 and can retain the Dublin edge. Twilio’s logs include a region filter to verify where messages were processed, and the post notes that Studio and TaskRouter support in IE1 is still an initiative.
Add an AI Voice Assistant to a Twilio Video Room with Conversation Relay
The tutorial addresses wasted patient time in telehealth waiting rooms by adding an AI voice assistant to a Twilio Video room for intake collection. It combines Twilio Programmable Video, Conversation Relay, and an LLM, with the assistant joining as an audio-only participant and handling questions about visit reasons, symptoms, and medications. A two-leg Voice call bridges the room to Conversation Relay: one leg participates in the room, while the other sends transcribed audio to a WebSocket server and returns spoken LLM responses. The tutorial uses Node.js, Express, the Twilio helper library, OpenAI, ws, dotenv, and ngrok, and explains setup, browser interaction, and troubleshooting. Its stated result is a working application in which a patient converses naturally with the AI before a provider joins, with GPT-4o-mini processing speech.
How to Build Passwordless Auth Using TOTP With Twilio Verify in PHP
Passwordless authentication can replace passwords with time-based one-time passwords (TOTP), but implementing the setup and verification flow requires coordinating an authenticator app with a verification service. This tutorial builds a web-based PHP application using Twilio Verify, Slim, Twig, and the Twilio PHP Helper Library. Users submit a username, create an initially unverified Factor resource, scan a QR code or enter its setup code, and submit the first six-digit code; later, they enter codes generated by the authenticator app for validation. The project configures Twilio credentials and a Verify Service SID through environment variables, adds session and flash-message support, generates QR codes, defines routes and templates, and runs locally with composer serve on port 8080. The conclusion presents TOTP passwordless authentication as more convenient and potentially more secure than passwords, while acknowledging added application complexity.
Multi-Vector (Late Interaction) Embedding Models with Sentence Transformers
Sentence Transformers v6.0 adds MultiVectorEncoder, bringing ColBERT-style late-interaction retrieval into the library’s existing API for dense, sparse, and reranker models. The encoder retains one projected, typically 128-dimensional vector per token instead of pooling a document into one vector, allowing documents to be encoded independently and indexed offline. At scoring time, MaxSim finds each query token’s highest dot-product match among document tokens and sums those maxima; contextual embeddings support both paraphrase matching and exact-token evidence. The guide covers checkpoint loading, encoding, scoring, semantic search, retrieval and reranking, indexing, token pooling, inference speed, evaluation, and retrieval from page images, audio, and video. It also quantifies the storage trade-off: 4,874 passages produced 608,414 token vectors and a 311.5 MB float32 index, while fast-plaid compression reduced that example to 92 MB.
Device Authorization Flow for a Rust CLI and an Axum API
Command-line tools lack browser redirect capabilities, preventing standard OAuth login flows. To resolve this limitation, the OAuth 2.0 Device Authorization Flow issues a temporary device code, presents a verification URL to the user, and waits for authentication in an external browser. A Rust workspace demonstrates this end-to-end pattern across a CLI, an Axum web API, and a shared authentication library. The shared library relies on jsonwebtoken and reqwest to fetch JSON Web Key Sets and validate token signatures, issuers, and audiences against typed claims. Axum secures protected routes through custom FromRequestParts extractors that decode Bearer headers, enabling verified CLI access.
Developing Nemotron 3.5 Lightning NVFP4 with QAD Using NVIDIA Model Optimizer
NVIDIA’s post presents a workflow for developing an NVFP4 checkpoint of the Nemotron 3.5 Lightning 30B-A3B model, targeting lower memory use and higher inference throughput without sacrificing accuracy. The method starts with post-training quantization (PTQ), producing a W4A16 student from the BF16 teacher, then applies quantization-aware distillation (QAD), where simulated quantization and KL-divergence loss align student logits with the frozen teacher. For the selected four_over_six recipe, 32K calibration performed best, and the recipe using W4A16 Mamba linears offered the best reported trade-off between accuracy degradation and inference performance; the checkpoint is 22 GB versus 66 GB and delivers up to 4x faster throughput. The workflow includes Model Optimizer examples and launchers for Megatron-LM and Megatron-Bridge, covering calibration, distillation, evaluation, and export.
A/B test models in production
A/B testing model changes in production by sending fixed shares of live endpoint traffic to one control and up to 20 variants, allowing teams to compare user-facing outcomes rather than relying only on shadow-traffic checks. The endpoint router keeps variants out of the base traffic split, resamples requests that reach the control, and treats experiment percentages as absolute shares independent of replica counts or autoscaling. A 95/5 experiment can be updated to 80/20 and then 50/50 by resending the complete member list; an etag rejects stale concurrent updates. Measurement joins per-deployment platform metrics with product signals using the deployment ID in response metadata. To finish, a winning variant is promoted through a blue-green rollout before deleting the experiment, while deletion alone returns traffic to the control and can unwind a losing test.
Using AI_Functions in Your Data Warehouse: Top Use Cases
Databricks AI Functions bring model inference into SQL queries, addressing the need to combine warehouse-resident structured data with unstructured reviews, tickets, PDFs, and transcripts without exporting rows to a separate service. The post presents six Lakehouse use cases: document parsing and extraction, sentiment classification, translation, ticket routing, sales-call extraction, and generative drafting with ai_query. Task-specific functions such as ai_parse_document, ai_extract, ai_classify, and ai_translate handle specialized work, while ai_query sends prompts to an accessible Databricks-hosted Foundation Model serving endpoint. Unity Catalog permissions, existing pipelines, and system.billing.usage keep governance and billing within Databricks, while SQL execution manages planning, parallelization, and retries. Production guidance includes tagging jobs, sampling at least 10,000 rows, choosing models deliberately, requesting structured output, and versioning prompts.
Record, train, and deploy from one place with Strands Agents, LeRobot, and Hugging Face Storage Buckets
This walkthrough presents a streaming data loop for Strands Robots that records robot demonstrations, stores them in Hugging Face Storage Buckets, trains from the growing dataset, and deploys a resulting policy back to hardware. It uses the LeRobot on-disk format throughout: Robot("so100") records through DatasetRecorder, sync_dataset_to_bucket writes changed bytes to a mutable bucket, and stream_dataset reads the dataset from the Hub without a full local download while decoding camera video on the fly. The agent can decide which episodes to keep and when to retrain, while the same Robot object records and streams data; deployment changes the robot mode keyword from simulation to real. The default simulation path runs with a mock policy that produces a valid dataset but not a useful one, while hardware, bucket, and training paths require additional dependencies.
Track generative AI costs with Amazon Bedrock inference profiles
When multiple departments share a single foundation model in Amazon Bedrock under one IAM role, usage aggregates into one billing line item, complicating department-level chargebacks and budget tracking. This issue can be resolved by deploying Amazon Bedrock application inference profiles wrapped around the shared foundation model and tagging each profile for cost allocation. The application layer determines the user department during authentication and passes the corresponding inference profile ARN as the model identifier. Once the designated cost allocation tag is activated in the AWS Billing and Cost Management console, usage separates into per-department line items in AWS Cost Explorer. This method incurs standard per-token model rates without extra charges for cost attribution.
Mastering Edge AI on Raspberry Pi with LiteRT and Gemma
Running edge AI on a Raspberry Pi 5 is presented as a way to build autonomous, low-latency systems that operate offline, with Reachy Mini serving as the demonstration. The setup combines LiteRT, LiteRT-LM, Gemma models, and LiteRT’s WebGPU (Vulkan) backend via ML Drift, splitting workloads between the CPU and VideoCore VII GPU. On CPU, Gemma 4 E2B reportedly reaches 99 tokens/sec prefill, 9 tokens/sec decode, and 1,432 MB peak memory; its tokenizer supports about 27.3 characters/sec in the voice demo. The pipeline runs YOLO object detection on the GPU, Moonshine speech recognition, Gemma reasoning, and text-to-speech on the CPU, while LiteRT CLI covers conversion, quantization, benchmarking, inference, and model execution from the LiteRT Hugging Face Community.
Using the GitHub Copilot SDK for Java
The GitHub Copilot SDK for Java offers a framework-agnostic client library to orchestrate AI agent sessions and tool execution directly from server-side Java code. Unlike framework-dependent alternatives, the SDK supports direct model providers such as OpenAI, Azure, and Anthropic through custom endpoint configurations without requiring a Copilot subscription. Developers can register tools declaratively using the experimental @CopilotTool annotation processor or dynamically through inline lambda definitions with ToolDefinition.from. When integrated into a Jakarta EE 11 application on Open Liberty, agent workflows run on container-managed virtual threads that propagate CDI and transaction contexts during blocking calls like sendAndWait. Real-time event subscriptions capture model execution steps and tool invocations to stream updates over WebSockets without exhausting platform threads.
Top topics
- Architecture830
- Performance812
- LLMs648
- Machine Learning617
- Open Source561
- AI Agents542
- AI454
- Developer Experience446
Weekly digest
The best engineering reads, once a week.