The Curious Engineer

All blogs / AI / ML

MachineLearningMastery.com

machinelearningmastery.com

Making developers awesome at machine learning.

AI / MLPython

’15’20’25
Posts
1,957 from 16 Nov 2013 to 30 Oct 2026
Posting
about daily (242 in the last year)
Kind
company blog
Feed
https://feeds.feedburner.com/MachineLearningMastery

Latest

October 2026

  1. 7 Ways Your AI Agent Is Wasting Tokens (And What to Do Instead)
  2. Fine-Tuning vs. Frozen Embeddings: When to Adapt the LLM vs. the Sklearn Head
  3. Context Managers Beyond Opening Files in Python
  4. Robust Serialization with JSON and Custom Types
  5. Speculative Decoding Explained: How to Get 3× Faster Inference from Any LLM
  6. How to Build a Multi-Modal RAG Pipeline for Images and Documents in Python
  7. pgvector vs. Dedicated Vector Databases: A Production Benchmark
  8. Descriptors and Controlled Attributes in Python
  9. Iterators and Generators for Memory-Efficient Processing
  10. Choosing a Chunking Strategy for Your LLM Apps: A Decision-Tree Approach
  11. Building a Custom LLM Evaluation Harness in Python from Scratch
  12. Building a RAG Pipeline with LLM Embeddings and Scikit-learn
  13. AI Agent Benchmarks Explained: SWE-Bench, GAIA, WebArena, and More
  14. How to Fine-Tune Llama 3 for Custom Tool Calling with Unsloth in Python
  15. Evaluating Graph-RAG vs. Standard RAG: A Hallucination Benchmark on Fact-Dense Queries
  16. Choosing the Right Agentic AI Framework for 2026: A Decision-Tree Approach
  17. Synchronous vs. Asynchronous Agent Execution: Architecture Patterns for Production
  18. How (and Why) to Build an AI Agent from Scratch in Python
  19. Adding Temporal Reasoning to Graph-RAG: Tracking Fact Freshness and Staleness
  20. AI Agent Observability: Logging, Tracing, and Debugging Explained

September 2026

  1. Automating Knowledge Graph Population: Extracting Entities and Triples from Unstructured Text with an LLM
  2. Local Agentic AI Workflows with Hermes + Ollama
  3. Tool Calling vs. Code Execution for AI Agents: Choosing the Right Action Primitive
  4. Agent or Workflow? A Practical Test for Knowing When You Actually Need an AI Agent
  5. RAG vs. Fine-Tuning for Domain Adaptation: When to Use Which
  6. Monitoring Embedding Drift in Production Scikit-LLM Pipelines
  7. The Roadmap to Mastering LLM Inference Optimization
  8. Build And Understand a Vector Database From Scratch in 10 Easy Steps
  9. What’s Actually Inside 24,723 Tokens of a Search Result? We Broke It Down, Field by Field
  10. Multilingual Text Classification with Scikit-LLM and Multilingual Embeddings
  11. The Roadmap to Mastering Voice Agents
  12. Treating Prompt Templates as Hyperparameters in Scikit-LLM GridSearchCV
  13. A Gentle Introduction to Model Distillation
  14. Fine-Tuning Agentic AI: A Practical Guide
  15. How to Combine Traditional Machine Learning with Agentic Reasoning
  16. Versioning and Tracking Scikit-LLM Experiments
  17. Chain of Thought vs. Tree of Thoughts: Which is Best for AI Agents?
  18. Dataclasses for Structured Application Data
  19. Single-Agent vs. Multi-Agent Systems: When the Complexity Is Worth It
  20. AI Agent Memory Design: What Works and What Doesn’t
  21. 3 Ways to Enhance Your AI Model’s Interpretability

August 2026

  1. Combining LLM Embeddings with Tabular Features in a Unified Scikit-learn Pipeline
  2. Interpretable Text Classification: Probing Scikit-LLM Embedding Spaces
  3. Learn Vectorized Thinking in Python Through Examples
  4. Comparing Local Tool Calling: Gemma 4 vs. Llama 3 vs. Mistral
  5. Integrating Agentic AI with Existing Machine Learning Pipelines
  6. How to Build a Robust RAG System with Minimal Resources
  7. Managing Small Context Windows in Language Models
  8. 7 Regression Tests Every AI Agent Should Pass Before Deploy
  9. Understanding the Role of Latent Space in Machine Learning Models
  10. Retrieval vs. Memory in Agentic AI Systems
  11. 7 Async Patterns for Running Agents Concurrently in Python
  12. Prompt Caching vs. Fine-Tuning: A Cost and Latency Decision Framework
  13. Identifying Token Costs Hiding in Your Agentic Loop
  14. Designing AI Agents That Can Self-Correct
  15. 7 Chunking Strategies That Decide Whether Your RAG Works
  16. Measuring Performance of Transformer Inference
  17. Static vs. Dynamic vs. Continuous Batching in LLM Inference
  18. Decoding Strategies and Output Control

July 2026

  1. Using a Transformer Model: From Training to Inference
  2. The End-to-End Agentic AI Pipeline
  3. Ollama vs. LM Studio vs. llama.cpp: Which Local AI Runtime Should You Use in 2026?
  4. 5 Architectural Patterns for Persistent Memory and State in AI Agents
  5. Stateful vs. Stateless Agent Design: Tradeoffs for Scalable Agentic Systems
  6. An Introduction to Loop Engineering
  7. The Current State of Agentic AI
  8. Building Agentic Workflows in Python with LangGraph
  9. Agentic AI Security: Defending Against Prompt Injection and Tool Misuse
  10. Run a Local AI Model with Ollama in 15 Minutes
  11. Scikit-Ollama for Scikit-LLM/Ollama Integration
  12. LLM Evaluation Frameworks Compared: How to Actually Measure What Your Model Does
  13. Building AI Agents? Here Are Some Anti-Patterns to Avoid.
  14. Choosing the Right AI Agent Memory Strategy: A Decision-Tree Approach
  15. LLM Orchestration Frameworks Compared: LangChain vs. LlamaIndex vs. Raw API Calls
  16. Tools vs. Subagents: Building Effective AI Agents Without Over-Engineering
  17. The Complete Guide to Tool Selection in AI Agents
  18. Context vs. Memory Engineering in Agentic AI Systems

June 2026

  1. Context Window Management for Long-Running Agents: Strategies and Tradeoffs
  2. Model Context Protocol Explained in 3 Levels of Difficulty
  3. The AI Agent Tech Stack Explained
  4. Agentic Workflow vs. Autonomous Agent: What’s the Difference?
  5. Context Windows Are Not Memory: What AI Agent Developers Need to Understand
  6. Clustering Unstructured Text with LLM Embeddings and HDBSCAN
  7. Building Browser-Using AI Agents in Python
  8. The Roadmap to Mastering AI Agent Evaluation
  9. Building an End-to-End Sentiment Analysis Pipeline with Scikit-LLM
  10. AI Agent Tool Design: What Works and What Doesn’t
  11. Python Concepts Every AI Engineer Must Master
  12. Multi-Label Text Classification with Scikit-LLM
  13. Multimodal Browser AI with Transformers.js for Images and Speech
  14. The Practitioner’s Guide to AgentOps
  15. Building Semantic Search with Transformers.js and Sentence Embeddings
  16. Using Scikit-LLM with Open-Source LLMs
  17. Scikit-LLM vs. Traditional Text Classifiers: When Should You Use an LLM?
  18. The Roadmap for Mastering LLMOps in 2026

May 2026

  1. Serving Multiple Users at Once: How Continuous Batching Keeps LLM Inference Efficient
  2. Building a Context Pruning Pipeline for Long-Running Agents
  3. The Statistics of Token Selection: Logits, Temperature, and Top-P Walkthrough
  4. Building a Multi-Tool Gemma 4 Agent with Error Recovery
  5. Implementing Hybrid Semantic-Lexical Search in RAG
  6. Building Context-Aware Search in Python with LLM Embeddings + Metadata
  7. How to Build a Multi-Agent Research Assistant in Python
  8. Agentic Programming: A Roadmap
  9. Prompt Engineering for Agentic AI
  10. Building Vector Similarity Search in PostgreSQL with pgvector
  11. Choosing the Right Agentic Design Pattern: A Decision-Tree Approach
  12. LLM Observability Tools for Reliable AI Applications
  13. Implementing Prompt Compression to Reduce Agentic Loop Costs
  14. Implementing Permission-Gated Tool Calling in Python Agents
  15. The Roadmap to Mastering Tool Calling in AI Agents
  16. Implementing Statistical Guardrails for Non-Deterministic Agents
  17. Agentic RAG Explained in 3 Levels of Difficulty

April 2026

  1. Effective KV Compression with TurboQuant
  2. Building AI Agents in Python with Pydantic AI
  3. Effective Context Engineering for AI Agents: A Developer’s Guide
  4. Text Summarization with Scikit-LLM
  5. Building AI Agents with Local Small Language Models
  6. Train, Serve, and Deploy a Scikit-learn Model with FastAPI
  7. AI Agent Memory Explained in 3 Levels of Difficulty
  8. Getting Started with Zero-Shot Text Classification
  9. The Complete Guide to Inference Caching in LLMs
  10. Python Decorators for Production Machine Learning Engineering
  11. 5 Techniques for Efficient Long-Context RAG
  12. How to Implement Tool Calling with Gemma 4 and Python
  13. Structured Outputs vs. Function Calling: Which Should Your Agent Use?
  14. Beyond Vector Search: Building a Deterministic 3-Tiered Graph-RAG System
  15. The Roadmap to Mastering Agentic AI Design Patterns
  16. A Hands-On Guide to Testing Agents with RAGAs and G-Eval
  17. Handling Race Conditions in Multi-Agent Orchestration
  18. Top 5 Reranking Models to Improve RAG Results
  19. 7 Machine Learning Trends to Watch in 2026

March 2026

  1. Building a ‘Human-in-the-Loop’ Approval Gate for Autonomous Agents
  2. From Prompt to Prediction: Understanding Prefill, Decode, and the KV Cache in LLMs
  3. 7 Essential Python Itertools for Feature Engineering
  4. LlamaAgents Builder: From Prompt to Deployed AI Agent in Minutes
  5. Vector Databases Explained in 3 Levels of Difficulty
  6. 5 Practical Techniques to Detect and Mitigate LLM Hallucinations Beyond Prompt Engineering
  7. Beyond the Vector Store: Building the Full Data Layer for AI Applications
  8. 7 Steps to Mastering Memory in Agentic AI Systems
  9. Why Agents Fail: The Role of Seed Values and Temperature in Agentic Loops
  10. 5 Production Scaling Challenges for Agentic AI in 2026
  11. 7 Readability Features for Your Next Machine Learning Model
  12. Everything You Need to Know About Recursive Language Models
  13. Building Smart Machine Learning in Low-Resource Settings
  14. Setting Up a Google Colab AI-Assisted Coding Environment That Actually Works
  15. From Text to Tables: Feature Engineering with LLMs for Tabular Data
  16. The 6 Best AI Agent Memory Frameworks You Should Try in 2026
  17. Vector Databases vs. Graph RAG for Agent Memory: When to Use Which
  18. 5 Essential Security Patterns for Robust Agentic AI
  19. Deploying AI Agents to Production: Architecture, Infrastructure, and Implementation Roadmap

Every year

2026 1872025 2802024 1572023 922022 1182021 1232020 1582019 1712018 1522017 1622016 1782015 222014 1392013 18