In today's newsletter:

• ​DailyDoseofDS is now on Instagram!
• ​Concepts of LLM serving​.
• Build a 100% local MCP server and client.
• ​[RECAP] A mini crash course on AI Agents!​

TODAY'S ISSUE

AI engineering

​DailyDoseofDS is now on Instagram!​

This newsletter regularly breaks down RAG architectures, AI agents, LLM internals, and everything in between.

Now we’re bringing all of that to Instagram too, in a format that’s quick to consume and hard to ignore.

We’re already 240 posts deep with content on RAG vs HyDE, agentic RAG, specialized AI models, prompt techniques, Bayesian optimization, active learning, and a lot more.

​You can find the account and follow it here →​

hands-on

​Concepts of LLM serving​

After covering LLM inference optimization in the full LLMOps course, we now move to the fundamentals of LLM serving.

​Read Part 14 of the full LLMOps course here →​

It covers how to actually make a language model accessible as a service: API-based providers vs. self-hosted inference, deployment topology decisions (on-prem, cloud, hybrid), serving with vLLM, and the practical trade-offs that determine how your LLM runs in production.

​Read Part 14 of the full LLMOps course here →​

Why care?

Optimizing inference (the previous chapter) is about making a single model run faster. Serving is about making that model reliably available to users.

These are different problems. You can have the most optimized inference stack in the world, but if your serving layer cannot handle concurrent users, if cold starts block requests, if you have no strategy for scaling up and down, none of that optimization matters in practice.

The serving layer is where engineering decisions directly translate into user experience and cost. Choosing between API providers and self-hosting changes your cost structure, latency profile, and data privacy posture. Choosing between on-prem and cloud changes your operational burden and scaling flexibility.

This chapter gives you the conceptual framework to make these decisions thoughtfully, along with hands-on experience serving models with vLLM.

• ​Read Part 1 on fundamentals of LLMOps here →​
• ​Read Part 2 on understanding the core building blocks of LLMs →​
• ​Read Part 3 on the key components of LLMs, focusing on the attention mechanism, architectures like transformers and mixture-of-experts, and the fundamentals of pretraining and fine-tuning →​
• ​Read Part 4 on decoding strategies, generation parameters, best practices, and the broader lifecycle of LLM-based applications →​
• ​Read Part 5 on context + prompt engineering from a system perspective, in-context learning, types of prompts, and different prompting techniques →​
• ​Read Part 6 on prompt versioning, defensive prompting, and techniques like verbalized sampling, role prompting, and more →​
• ​Read Part 7 on context engineering, covering context types, context construction principles, and retrieval-centric techniques for building high-signal inputs →​
• ​Read Part 8 on memory, dynamic, and temporal context in LLM systems, covering short and long-term memory, dynamic context injection, and common context failure modes in agentic applications →​
• ​Read Part 9 on evaluation methods and approaches for LLM-based applications, primarily focusing on building a strong understanding of the fundamental concepts →​
• ​Read Part 10 on evaluation benchmarks in LLM applications, with task-specific methodologies, and the core tooling for evaluation of LLM apps →​
• ​Read Part 11 on evaluation of multi-turn systems, tool use evaluations, tracing, and red teaming →​
• ​Read Part 12 on LLM fine-tuning, parameter-efficient methods like LoRA and QLoRA, and alignment techniques such as RLHF, DPO, and GRPO →​
• ​Read Part 13 on LLM inference optimization, KV caching, PagedAttention, FlashAttention, speculative decoding, and model parallelism →​

Over to you: What would you like to learn in the LLMOps course?

hands-on

​Build a 100% local MCP server and client​

Claude Desktop and Cursor rely on external LLMs to leverage MCP capabilities.

When building enterprise-grade solutions, keeping your data on your own servers becomes critical.

This is where learning to build local MCP clients becomes essential.

Let’s learn that today by building a 100% local MCP server and client.

Stack:

• Build a 100% local and secure MCP client using mcp-use.
• Integrate the client with the Stagehand MCP server.
• Use this setup to control and automate the browser.

A quick background before we get into the code.

MCP follows a client-server architecture where:

• Host (Agent/IDE) runs the MCP Client to communicate with MCP Servers.
• MCP Servers expose tools that can perform various actions.

This architecture enables secure and standardized AI tool integration.

With this understanding in mind, let's start building our own MCP servers and clients.

1️⃣ Build a simple MCP server

First, we create a simple MCP server using FastMCP with a tool that adds two numbers.

• Decorate the method with the specified decorator.
• Add a docstring to the method.
• Implement the functionality.

Then create a configuration file that tells any client how to connect to this server.

2️⃣ Create MCP Client

Next, we build a client using mcp-use, powered by locally running LLMs.

It's completely secure and can run on your machine.

Let's integrate the MCP client and server we just created.

Here's a Streamlit UI for better accessibility that wraps the client we created above.

For didactic purposes, we're starting with a very simple server.

Now, let's make this more practical. We're going to build a browser automation MCP server using Stagehand.

With this, we can navigate websites, click buttons, fill out forms, and extract data using natural language commands (full code is in the GitHub repo shared later).

Here is the implementation:

Next, let's interact with the Stagehand MCP server.

In the video below, when asked to find the cheapest flight from one city to another:

• It navigated to Google.
• Typed in the query.
• Scraped the relevant information.
• Returned the results to the agent to generate a response.

That was simple, wasn’t it?

We used mcp-use because you can use it to connect any LLMs to MCP servers & create local MCP clients easily.

• Compatible with Ollama & LangChain
• Stream Agent output async
• Built-in debugging mode, etc

​Find the GitHub Repo here →​

​Find the code for this project on GitHub here →​

Agents

​[RECAP] A mini crash course on AI Agents!​

Some time back, we released a free mini crash course on building AI Agents:

This is a good starting point for anyone to learn about Agents and use them in real-world projects.

It covers:

• What is an AI Agent
• Connecting Agents to tools
• Overview of MCP
• Replacing tools with MCP servers
• Setting up observability and tracing

Everything is done with a 100% open-source tool stack.

​You can find the entire code in this GitHub repo →​

THAT'S A WRAP

Partner with US

ADVERTISE TO 900k+ AI Professionals

Our newsletter puts your products and services directly in front of an audience that matters, including thousands of leaders, senior data scientists, machine learning engineers, data analysts, etc., around the world.

Get in touch today by replying to this email.

Today’s email was brought to you by Avi Chawla and Akshay Pachaar.

​Update your profile | Unsubscribe​

Looking for more? Unlock our premium DS/ML resources.

© 2026 Daily Dose of Data Science