Ankit Mishra's Blog

Embracing the Emptiness

2025-12-17T00:00:00Z

Hey, how are you. i hope you’re happy and doing well. I don’t write very often. When I do, it’s usually unplanned more like reflections or random thoughts.

Lately, there’s been a lot of silence. Not the dramatic kind, just the kind that exists when things stop demanding attention. Nothing is particularly wrong. Nothing is particularly right either.

At some point, I noticed that emptiness isn’t always a problem to solve. Sometimes it’s just a phase where things are being rearranged quietly, without any announcement.

Life keeps moving as expected. Time moves, People stay buzy, Plans continue. Yet internally, there’s a neutral space where reactions slow down and thoughts become more deliberate.

I used to think emptiness meant something was missing.
Now it feels more like something unnecessary has left.

There are no big conclusions here. No lessons wrapped in optimism. Just an observation.

So, this is a snapshot shaped over time, written down on 17th December, late at night. Let’s see if the perspective shifts.

Why MCP (Model Context Protocol) is Here to Stay!

2025-04-25T00:00:00Z

You’ve likely heard the buzz about MCP (Model Context Protocol) — and I firmly believe it’s here to stay.

But what exactly is MCP, and why does it matter? Let’s break it down simply.

What is MCP?

MCP is a fundamental shift in the software development ecosystem. It introduces a new standard that redefines how AI Agents interact with external systems, making integrations seamless, reusable, and efficient.

Why Did We Need MCP?

Let’s say you’re building an AI agent that needs to talk to:

Gmail
A custom database

Traditionally:

You manually write integrations for each API.
You define authentication, permissions, and logic from scratch.
Adding another agent? You repeat the entire process.

The Inefficiencies of the Old Way

Redundant integrations per agent
Inconsistent API logic (e.g., Gmail allows email deletion, but your use case might only need sending)
No easy way to scale, since logic has to be redefined again and again

How MCP Fixes This

MCP introduces a unified abstraction layer, acting as a standardized protocol between AI agents and APIs. This eliminates the need for redundant integration logic.

It’s like having a central translator that speaks both API and AI-agent.

Before MCP:

Each AI agent has to handle API interactions separately.

With MCP:

AI agents simply communicate with the MCP server, which manages the requests for them.

The Result

Faster Development
Reusable APIs
Standardized Permissions
Agent-Agnostic Workflows

Final Thoughts

MCP isn’t just another buzzword — it’s a foundational layer for building scalable AI ecosystems.

Whether you’re building agents for customer service, health records, or internal tooling — MCP will help you avoid technical debt and grow faster.

If this topic intrigued you, feel free to connect with me or share this post with your network.

Accuracy Without Context Is Like a Ship Without a Compass

2025-04-21T00:00:00Z

Ah yes, the classic beginner's mindset: if the accuracy number is high, the model must be a genius! Logic? What’s that?

Accuracy Without Context Is Like a Ship Without a Compass

Many beginners believe that higher accuracy automatically indicates better model performance. However, there's much more to the story of machine learning when applied in the real world.

The Scenario

Imagine you're building a multi-class classification model to predict three types of fruits: Apples, Bananas, and Cherries.

Here are the model’s accuracy scores after testing:

Apple: 80% accuracy
Banana: 80% accuracy
Cherry: 60% accuracy

Seems obvious, right? Cherry is the worst-performing class. But hold on! Your answer might be correct for your college project or any hackathon, but this is not how real-world ML works!

There’s more to this story.

What’s Missing? The Baseline

What you’re missing is a baseline.

Without a comparison, accuracy numbers alone can be misleading. In machine learning, the baseline is not just a reference point, it’s the context that defines our understanding of model performance. Without it, accuracy becomes an illusion, masking the true strengths and weaknesses of our systems.

Manually Labelling by Humans

In this scenario, let’s set the baseline by asking team members to manually label the same fruit images.

Here’s how they performed:

Apple: 85% accuracy
Banana: 100% accuracy
Cherry: 61% accuracy

What We Learn from the Baseline

Now things get interesting. Based on this baseline, it’s clear that:

The model performs close to humans on cherries (60% vs. 61%).
It struggles significantly with bananas (80% vs. 100%), even though 80% might seem fine at first glance.
For apples, it’s almost there, but not quite matching human performance.

What’s the Lesson Here?

Accuracy doesn’t tell the full story. You need to measure against a baseline, whether it's human performance or a simple method like random guessing, before deciding where your model truly struggles.

Many ML beginners tend to focus on the lowest accuracy class as the problem area, but context matters. Without a proper baseline, you might be focusing on the wrong issues.

Final Thoughts

So, the next time you're evaluating a model, remember: accuracy is only as good as the context it's placed in.