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
How to Confirm Phone Number Ownership with Lookup Identity Match in Python
The tutorial shows how to use Twilio Lookup Identity Match in Python to confirm that signup information is associated with a phone number and reduce signup fraud. It builds a Flask application that accepts an E.164-formatted number, first name, and last name, then calls the Lookup API with fields="identity_match" and the supplied identity attributes. The response exposes statuses including exact_match, high_partial_match, no_match, and no_data_available; the example accepts a result only when the number is valid and both names are exact or high partial matches. The implementation covers project setup with Flask, twilio, and python-dotenv, environment-based credentials, an intl-tel-input form, and frontend handling for success and failure messages. It also notes that Identity Match can use combinations of name, address, national ID, or date of birth, and points to other Lookup packages such as Line Type Intelligence and SIM swap detection.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify in Python
This Python tutorial builds a signup flow that screens phone numbers for fake accounts while aiming to keep legitimate onboarding smooth. It combines Twilio Lookup’s Line Type Intelligence, optional Line Status, and Identity Match checks before using Twilio Verify to send an OTP and confirm possession of the number. The provided Flask example collects a phone number and first and last names, rejects landlines, nonfixed VoIP, toll-free numbers, and pagers, and accepts Identity Match only when both name fields are exact_match or high_partial_match. The post shows how to configure the project, run it locally, inspect outcomes such as LINE_TYPE_BLOCKED or identity-match failure, and consider pricing because the four API calls have different costs.
How to Train a Cross-Embodiment Robot Navigation Policy with AI Agents
The tutorial presents an agent-driven workflow for adapting robot navigation across embodiments and scenes, addressing the repeated cost of collecting data, preparing simulation assets, training, diagnosing, and evaluating each robot-scene pair. Using Boston Dynamics Spot, it applies COMPASS to a built-in warehouse and a SAGE-10K scene, with NVIDIA Omniverse NuRec described as an option for captured environments. COMPASS reuses the pretrained NVIDIA X-Mobility navigation policy and trains a residual reinforcement-learning specialist that corrects base actions for a selected robot and environment; specialists can later be distilled into a shared policy. Repository skills guide dependency checks, asset preparation, smoke testing, training, checkpoint comparison, and packaging, while human gates control scene acceptance, smoke-test continuation, and checkpoint promotion. Runtime integration converts camera images, goals or routes, and speed from odometry into velocity commands, with cuVSLAM available separately when compatible odometry and transforms are unavailable.
Automating Red Hat OpenShift AI installations with Helm and GitOps
Deploying Red Hat OpenShift AI manually across multiple environments is error-prone due to the numerous required dependencies, including certificate managers, job queuing systems, and GPU operators. To streamline this lifecycle, the odh-gitops repository introduces the rhai-on-openshift-chart Helm chart. The chart automates operator provisioning through Operator Lifecycle Manager and configures custom resources such as DataScienceCluster. Dependency resolution is controlled via a tri-state model that automatically installs prerequisites like cert-manager and Red Hat Connectivity Link when dependent components are enabled. Using this chart, teams can deploy full platform installations or minimal inference stacks through standard Helm CLI commands or Argo CD GitOps pipelines.
GRPO fine-tuning on Red Hat OpenShift AI: Reinforcement learning from verifiable rewards with Training Hub
Supervised fine-tuning for structured reasoning tasks like tool calling often demands expensive, labor-intensive dataset curation. Group Relative Policy Optimization (GRPO) resolves this by using programmatic reward functions to score multiple candidate responses without requiring human labels or a dedicated reward model. On Red Hat OpenShift AI, developers can implement GRPO using Training Hub, Kubeflow Trainer, and the Kubeflow SDK to fine-tune models like Qwen3-4B. The setup utilizes vLLM for candidate generation alongside LoRA weight updates, sharing storage via ReadWriteMany persistent volume claims. In a practical tool-calling test, five training iterations raised task accuracy from 33% to 67%, teaching the model to emit parseable function invocations rather than fabricated conversational text.
Build a Video Chat Application with Python, JavaScript and Twilio Programmable Video
This tutorial builds a browser-based video chat application using Python, Flask, vanilla JavaScript, HTML, CSS, and Twilio Programmable Video. It adds text chat through Twilio Conversations and screen sharing, allowing participation on modern desktop and mobile browsers without installed software. The implementation covers Twilio account and API-key setup, environment variables, a Python virtual environment, client-side event handlers, and ngrok, which exposes the local Flask server through an HTTPS public URL for testing on other devices. The refreshed project targets Flask 3.x, twilio-python 9.x, Twilio Video JS 2.35.x, and Twilio Conversations classic JS 2.x, and the completed flow supports live calls, screen sharing, and text chat. Participants must use unique names because Twilio identifies them by token identity.
Training and Finetuning Multi-Vector Embedding Models with Sentence Transformers
Sentence Transformers v6.0 adds MultiVectorEncoder, a fourth model type for ColBERT-style late-interaction retrieval, alongside a training approach for finetuning existing models or building them from base transformers. Multi-vector models retain one small vector per token and score query-document pairs with MaxSim, where each query token selects its best document-token match and the scores are summed. The guide covers models, datasets, loss functions, training arguments, evaluators, trainers, callbacks, and multi-dataset training, with examples using pip install -U "sentence-transformers[train]". On a medical retrieval evaluation, the finetuned multi-vector-encoder/mLateOn-medical model, trained for 14.5 hours on a single RTX 3090, outperformed every general-purpose retrieval model tested across dense, sparse, lexical, and multi-vector systems.
Supercharge Auth with Signals and the New Okta Angular SDK
The updated Okta Angular SDK introduces fully standalone architecture, eliminating NgModules and wrapper functions in favor of standalone providers and functional guards. In an Angular v22 sample project, authentication is configured with the provideOktaAuth function without requiring a custom backend. Route security utilizes functional guards, while user and group data fetch flows are handled using rxResource alongside signal inputs. To support dynamic environments without requiring rebuilds or redeployments, the setup implements runtime configuration loading via provideAppInitializer and OktaAuthConfigService. Security is further bolstered by binding access tokens to browser key pairs using Demonstrating Proof of Possession alongside OAuth 2.1 and OpenID Connect protocols.
The Email Verification API
The proposed Email Verification API lets a browser verify that a submitted email address belongs to the user without sending them away from the current form to retrieve an OTP or magic link. Its flow involves the user, browser, mailbox provider (issuer), and application server (verifier): after mailbox registration, the browser and issuer create a token that is submitted with the address and checked server-side. Implementation requires an email input, a hidden email-verification-token input with a session-bound random nonce, and token verification using the site origin as audience; a JavaScript package handles parsing, lookups, and signature checks. The proposal is currently limited to Chrome’s origin trial and Gmail mailbox verification, so the source recommends progressive enhancement and other verification APIs where unavailable.
Build a Serverless Video Chat Application with JavaScript and Twilio Programmable Video
This tutorial builds a basic browser-based video conferencing application with JavaScript, HTML, and CSS using Twilio Programmable Video. It targets desktop and mobile web browsers, requiring no installed client, and uses the Twilio Serverless platform to provide hosting and a public URL. The setup creates a Twilio Serverless project, configures ACCOUNT_SID, API_KEY_SID, and API_KEY_SECRET in .env, runs npm start locally, and deploys with twilio serverless:deploy; the client manages joining, participant video streams, disconnection, and participant counts. After deployment, users can open the generated index.html URL on separate devices or share it with others to see participants appear dynamically, while the conclusion notes additional Twilio Video capabilities such as recording, custom data tracks, screen sharing, and virtual backgrounds.
Wire It, Run It, Deploy It: AI Workflows in Gradio
AI applications are presented as pipelines that chain image, text, audio, and dataset operations, with intermediate values otherwise investigated through print-debugging. gr.Workflow turns these pipelines into graphs of typed nodes, served as a drag-and-drop canvas where each node runs independently and its result remains visible. Operators can be Python functions, Hugging Face Inference Providers models, Gradio Spaces, Hub dataset rows, or GPU-backed functions using ZeroGPU, while fan-out connections run multiple analyses or generations in parallel. The same workflow also exposes labeled outputs as REST endpoints callable through the Gradio client or curl, and can be deployed to Hugging Face Spaces with one command.
Run LoRA fine-tuning on Red Hat OpenShift AI with Ray
Red Hat OpenShift AI 3.5 integrates Ray cluster runtime images with preinstalled Training Hub packages to support distributed fine-tuning algorithms including LoRA, SFT, OSFT, and GRPO. Using the CodeFlare software development kit within a Jupyter workbench, developers can provision an elastic single-GPU Ray cluster attached to shared ReadWriteMany persistent storage containing model weights and training datasets. The tutorial demonstrates fine-tuning the Qwen2.5-1.5B-Instruct model on the public sql-create-context dataset to produce direct, bare SQL output without explanatory conversational text. After training completes, the workbench loads and merges the resulting LoRA adapter checkpoints with the base model to evaluate output format correctness against sample database schema questions. The RayCluster automatically tears down resources once the job concludes, while the shared pipeline architecture allows switching between supported fine-tuning algorithms by modifying dataset inputs and configuration parameters.
Add Cross App Access to Your OIDC Resource Application
Cross App Access allows applications such as AI agents to access resource APIs on behalf of OpenID Connect federated users. The specification relies on an Identity Assertion Authorization Grant, which is a short-lived JSON Web Token issued by the customer Identity Provider. Resource authorization servers validate this token, resolve user identities using combined issuer and subject claims, and issue locally scoped access tokens without altering single sign-on flows. Implementations must bind issuers to registered connections before verifying signatures to prevent forgery attacks. In addition, servers should not issue refresh tokens, as clients instead resubmit the grant upon access token expiration.
How to Evaluate Live & Voice Agents in ADK
ADK now supports native evaluation of live, voice-based agents, addressing regressions in tool use, context continuity, turn-taking, timing, and recovery that may not appear in demos. The walkthrough builds a graph-based workflow of three single-purpose agents running gemini-live-2.5-flash-native-audio, with a mocked date-of-birth tool between stages and session state carried across the open audio stream. It shows how to author scenario-based or fixed conversations, synthesize simulated user turns with Gemini TTS, configure live mode and rubric-based multi-turn trajectory judges, and run evaluations from the CLI or AgentEvaluator. ADK Web then reconstructs the audio as transcripts with playable clips, while configurable voices, languages, invocation limits, thresholds, and per-turn metrics support repeatable debugging and CI/CD regression checks.
Adding a UI to an Auth0-secured MCP server with Skybridge
Skybridge can return a React view alongside structured data from an MCP tool, allowing hosts such as ChatGPT, Claude, and VS Code to render an interface in the conversation. The tutorial scaffolds an MCP app, adds Auth0 through Skybridge’s auth0Provider, and protects the /mcp transport with bearer JWT verification before requests reach tool handlers. Auth0’s default opaque tokens create a compatibility issue because MCP clients send RFC 8707 resource indicators rather than an audience, so Skybridge advertises an authorization endpoint that includes the API audience. The view receives the verified user identity through structuredContent instead of relying on a name supplied by the model. Its additional tool calls use the same authenticated MCP session, and testing proceeds through DevTools, the Playground, real hosts, and deployment.
Running AI agents in GitHub Actions with Docker Sandboxes
GitHub Agentic Workflows added support for Docker Sandboxes as an agent runtime, allowing CI coding agents to operate within microVM isolation. Useful AI agents require broad capabilities like executing arbitrary shell commands and launching containers, which elevates risk on shared CI runners. With the docker-sbx runtime, agents receive root privileges and a private Docker daemon inside a dedicated microVM while external repository access and network traffic remain restricted. In a demonstration, an agent ran on an Ubuntu runner, executed Java 21 integration tests with PostgreSQL via Testcontainers, identified an email case-sensitivity defect, applied a code fix, and opened a draft pull request. The complete workflow executed in eleven minutes and sixteen seconds while confining modifications strictly to source files.
Add Cross App Access to Your OIDC Requesting Application
OpenID Connect federated applications connecting to third-party services can implement Cross App Access using the Identity Assertion Authorization Grant specification. When a user authenticates via the standard authorization code flow, the requesting application retains the issued refresh token. The application exchanges this refresh token at Okta's token endpoint via RFC 8693 token exchange to receive a short-lived Identity Assertion Authorization Grant JSON Web Token. Next, the application presents this assertion to the third-party resource authorization server using the RFC 7523 JWT bearer grant to obtain a final access token. Developers can configure an AI Agent and application integrations in Okta to validate the entire end-to-end request flow against test endpoints on xaa.dev.
Busting SQL Migration Myths: How New SQL Features Make Lift-and-Shift to Lakehouse Easier
The post addresses the procedural core of warehouse-to-lakehouse migrations: legacy stored procedures that use temporary tables, cursors, control flow, multi-table updates, and transaction handling while remaining maintained by SQL teams. Using a composite daily-orders procedure based on an Oracle migration, it translates rather than rewrites the logic on Databricks, covering procedure registration in Unity Catalog, session-scoped temporary tables, cursor syntax, handlers, conditional scripting, and atomic transactions. Databricks SQL scripting supports cursors from Runtime 18.1, and BEGIN ATOMIC provides automatic commit or rollback plus row-level conflict detection; catalogManaged tables are required inside atomic blocks. The post says this mechanical translation can cut migration timelines by 50–75% for complex procedures, while preserving business logic and allowing the SQL team to maintain it, though the procedure still needs validation in a migration project.
Video Call Integration on Different Platforms
Video calling can add direct, personal communication to customer and patient interactions without moving conversations to a third-party app or website. The post outlines an integration path based on choosing a platform, selecting development-specific SDKs, and either building a custom application or deploying and adapting an open-source one. Twilio is presented as a cloud communications platform offering APIs, SDKs, reference apps, and documentation, with SDKs for JavaScript, Android, and iOS; listed build examples also use Svelte, Go, Python, ASP.NET Core, Angular, Node.js, TypeScript, and Express. Open-source options provide features such as screen sharing and network-condition monitoring, while Twilio Video supports branded virtual backgrounds and layouts, but the source does not report implementation results.
Enterprise-Managed Authorization for your MCP server: Setting Up and Testing XAA in Auth0
Connecting AI agents to enterprise APIs and MCP servers creates governance challenges when relying on traditional OAuth consent prompts. Cross App Access shifts authorization decisions to the enterprise identity provider, allowing IT administrators to manage agent permissions centrally. In this architecture, an identity provider like Okta authenticates the user and issues an Identity Assertion JWT Authorization Grant based on administrative policy. The requesting AI agent presents this assertion to Auth0, which validates the signature and exchanges it for a standard access token via a JWT-bearer grant. Protected APIs can then validate the final token normally without requiring code changes or direct user consent interactions.
Top topics
- Architecture830
- Performance812
- LLMs648
- Machine Learning617
- Open Source561
- AI Agents542
- AI454
- Developer Experience446
Weekly digest
The best engineering reads, once a week.