Forem: Manish Tyagi

You're Building AI Wrong — Here's How MCP Fixes It

Manish Tyagi — Mon, 16 Jun 2025 00:05:44 +0000

You're staring at your screen, trying to get your AI assistant to do something that seems simple. "Summarize the latest sales report and draft an email to the team with the key takeaways," you type. But the AI, as powerful as it is, is stuck. It doesn't have access to your company's sales data, and it can't send emails. You're left with the tedious task of copying and pasting, feeling like you're the one assisting the AI. Sound familiar? We've all been there.

Why Today's AI Falls Short

We have these incredibly powerful AI models, but connecting them to your data, tools, and workflows often feels like a brittle, bespoke mess. Legacy infrastructures, security limits, real-time data demands, and compliance requirements (GDPR, HIPAA, etc.) add layers of complexity that AI can't reliably navigate on its own .

But what if there was a way to give these AI brains not just a voice, but hands? A way for them to seamlessly interact with all the apps, systems, and data you rely on - securely, predictably, and at scale?

That's the promise of the Model Context Protocol (MCP), born from Anthropic's vision and driven by an open-source community. It may not grab headlines like frontier LLM hype, but MCP represents a critical infrastructure layer enabling scalable, context-aware AI systems.

The "USB-C for AI" that Just Works?

Before MCP, connecting an AI model to a new tool was a custom, one-off job. Want your AI to read your Google Drive files? That's one integration. Want it to interact with your GitHub repository? That's another. This created a messy, tangled web of connections that was a nightmare to maintain. This is often referred to as the "N x M problem" - for every N models, you needed M custom integrations.

It's not just about syntax, most systems struggle with semantic interoperability - ensuring shared data carries meaning across platforms and schemas. Without shared vocabularies and context metadata, AI can misinterpret data or generate responses that miss the mark.

MCP solves this by creating a single, standardized port. With MCP, you can plug any AI model into any tool or data source that also "speaks" MCP. This "plug-and-play" approach is a game-changer for developers and users alike.

In a nutshell, the Model Context Protocol (MCP) is an open standard that lets AI models, tools, and data sources talk to each other in a common language. Think of it like a universal translator or, as many in the tech world have dubbed it, the "USB-C for AI."

The Story Behind

The Model Context Protocol (MCP) was officially introduced by Anthropic on November 25, 2024, as an open-source project to bridge AI models with real-world tools and data sources. At its core, MCP tackled the "M×N integration problem" - the headache of building custom connectors for each model-tool combination.

In the early days, MCP was a niche project but it quickly gained traction with developers, who lauded it as "USB‑C for AI apps," enabling Claude - or any compliant AI client - to access GitHub, SQL databases, Google Drive, Slack, and more, with just one integration. A case in point: Anthropic demonstrated a working MCP-based GitHub pull-request workflow in under an hour using Claude Desktop

By early 2025, the support broaden significantly. OpenAI, Google DeepMind and Microsoft announced their support for MCP. Today, an ecosystem of major adopters surrounds MCP. Companies like Block, Zed, Sourcegraph, and Replit have rolled out MCP-based integrations, alongside numerous community-built MCP servers.

Much like HTTP and HTML catalyzed the open web, MCP is emerging as the open infrastructure layer for next‑gen AI

How Does MCP Works - A Peek Under the Hood

Let's get straight into its working- MCP uses a client-host-server architecture built on JSON‑RPC 2.0, enabling stateful, secure sessions for sharing context and coordinating AI actions.

MCP Host: This is the user-facing application, like an AI-powered IDE or a chatbot. It's the "container" that manages the connections.
MCP Client: This is an intermediary that lives within the host application and manages a secure, one-to-one connection with a specific MCP server.
MCP Server: This is a lightweight server that provides access to a specific tool or data source, like the GitHub API or your local file system.
Local Data Sources: On-premises assets like your computer's files, databases, and services that MCP servers can securely access.
Remote Services: External systems over the internet- like cloud APIs and SaaS tools - that MCP servers can connect to

Additional Elements

Tools: Callable functions (e.g., run tests, generate charts) exposed by the server.
Resources: Read-only data endpoints (e.g., files, database queries) included in context payloads.
Prompts: Pre-defined templates guiding how tools/resources are invoked

Here's a simplified workflow of how an AI Agent might use MCP to help you with a coding task:

You ask for help: You ask your AI Agent, "Can you review the latest pull request in the 'frontend' repo and summarize the changes?"
The AI makes a request: The Agent, acting as an MCP client, sends a request to the GitHub MCP server.
The server gets to work: The MCP Server receives the request. It determines the source type and begins to fetch the necessary pull request data.
The server responds: The MCP Server sends this Standardized pull request data back to the MCP Client. The MCP Client then pulls this data.
AI gives you an answer: The AI Agent receives the summarized data and suggestions from the MCP Client. It then processes this information to Summarize and suggest improvements and provides you, the User, with an answer: Here is a summary of the pull request and suggested improvements.

While this flow occurs, crucial background operations are simultaneously performed by the MCP Host and MCP Server to ensure auditability and data governance:

The MCP Host logs the "User request for audit."
The MCP Server logs "Data access event" related to its data retrieval.

This all happens seamlessly in the background, in a matter of seconds. The beauty of MCP is that the AI assistant doesn't need to know the nitty-gritty details of various APIs like GitHub's. It just needs to know how to speak MCP, and MCP handles the complex data integration and standardization.

Extending MCP with Plugins

MCP isn't just flexible - it's extensible too. With plugins, you can customize how your AI interacts with tools, data, and security policies:

Transformers: Auto-upgrade frames between schema versions.
Sanitizers: Remove PII automatically.
Validators: Enforce custom business rules.

Where Can It Help?

The best way to understand the power of MCP is to see it in action. Here are a few examples of how MCP is being used today:

AI That Understands and Writes Code: Tools like Sourcegraph's Cody and Codeium tap into MCP to read local files, run tests, and interact with version control systems. These integrations give the AI a holistic grasp of the codebase, improving its ability to generate accurate suggestions.
Natural Language to Data Insights: MCP enables direct connections from AI agents to SQL databases, Snowflake, BigQuery, and more. These agents can translate natural-language prompts into SQL, fetch data, and produce context-aware BI reports - streamlining insights for non-technical users.
Project & Team Management: AI assistants can now create tasks, send Slack updates, and generate project reports by integrating with tools like Jira, Asana, Linear, and Slack via MCP servers - simplifying collaboration and automating routine workflows.
Secure Enterprise Data Access: With MCP servers deployed within a business's infrastructure, companies retain full data governance and privacy control, even as models interact with internal files, databases, and APIs - meeting strict compliance and security standards.

What's Next?

As more tools and data systems start supporting MCP, we'll see the rise of composable AI systems - where different models, services, and data sources can work together seamlessly. This will empower teams to build custom AI Agents tailored to their workflows, industries, & environments.

As adoption grows, MCP will become the standard infrastructure layer for AI applications, unlocking everything from personalized research copilots to enterprise-grade, domain-specific agents. Instead of being limited to chat responses, AI will be able to read, write, take actions, and integrate into how we already work - securely and at scale.

Wanna dive deeper? Start your journey from here -

Official Spec: modelcontextprotocol.io/
GitHub Repo: github.com/modelcontextprotocol

Qubits Explained: The Building Blocks of Quantum Computing

Manish Tyagi — Sun, 20 Aug 2023 12:13:34 +0000

Introduction

Quantum computing represents an innovative approach to computation, embracing the principles of quantum mechanics, like superposition and entanglement, to skillfully manipulate information at the quantum level.

Quantum computing is revolutionizing the way we approach complex problems, and at the heart of this technology are qubits, or quantum bits. In this blog, we'll explore the fundamental concepts of qubits, their various implementations, and the operations that make them so powerful. We'll also discuss their applications in quantum computing, simulation, and sensing, and take a look at the current state and prospects of this fascinating field.

What is a Qubit?

Qubits, or quantum bits, are the basic units of information in quantum computing. While classical computers use bits that are either 0 or 1, qubits can be in a superposition of 0 and 1 simultaneously. This allows qubits to encode more information than classical bits and enables the massive parallelism that gives quantum computers their potential computing power.

For example, a classical bit can be represented as:

0 = OFF
1 = ON

Mathematically, a qubit's state can be represented as:

|ψ⟩ = α|0⟩ + β|1⟩

Where |0⟩ and |1⟩ are the two basis states and α and β are complex probability amplitudes satisfying:

|α|^2 + |β|^2 = 1

The probability amplitudes determine the probabilities of measuring 0 or 1 when the qubit collapses during measurement.

Importantly, the qubit can be in a coherent superposition of |0⟩ and |1⟩, where both states exist simultaneously with their respective probabilities. This enables the massive parallelism of quantum computing

In simple terms, we can think of a qubit like a coin that is simultaneously heads and tails until we observe it. Then it collapses into either heads or tails (somewhat similar to a double-slit experiment ).

Qubit Implementations

Qubits can be implemented using any two-level quantum system. Some of the main implementations are:

Photons: The polarization states of a photon can encode a qubit.
Electron spins: The spin-up and spin-down states of an electron act as the two levels.
Nuclear spins: The nuclear spins of atoms can also encode qubits.
Superconducting circuits: Josephson junction-based circuits have two energy states that act as qubits.
Ion traps: The electronic or vibrational states of trapped ions can form qubits.

Qubit Operations

Let's talk about how qubits work in a friendly way.

Qubits can be represented in various forms like electron spins, nuclear spins of atoms, superconducting circuits, or even trapped ions. Cool, right?

Now, let's dive into qubit operations:

Qubits can be played around using quantum gates, and we can measure them to get some useful information.
Quantum gates are like the cool cousins of logic gates, and they help us perform operations on qubits. Some popular ones are the Hadamard gate (H), Phase gate (S), and CNOT gate.
When we measure a qubit, it's like a coin toss - it can end up as |0⟩ or |1⟩, depending on the probabilities.
Initialization is like setting the stage for a qubit, usually starting with |0⟩.
Entanglement is when qubits become inseparable buddies, showing connections that are even stronger than what classical physics allows.

I hope that explanation wasn't too complex, and now you have a grasp of qubits and their operations in a more approachable manner!

Applications of Qubits

Qubits form the foundation for quantum algorithms and applications:

Quantum computing: When you put a bunch of qubits together, they can work on problems that regular computers struggle with. It's like having a super-powered team!
For instance, Shor's algorithm uses qubits to factor large numbers, which could potentially break current encryption methods.
Quantum simulation: Qubits can act like other quantum systems, helping us understand things that are just too tricky for old-school methods.
For example, qubits can be used to model complex quantum systems, such as chemical reactions, leading to advances in materials science and drug discovery.
Quantum sensing: Qubits are like super-sensitive detectives, picking up on the tiniest changes in things like magnetic fields and electric fields. They're incredibly precise!
For example, qubits can detect minute changes in physical properties, enabling more accurate measurements in fields like geology, medicine, and navigation.

This is what a real Quantum Computer looks like

IBM 50-qubits Quantum Computer, November 10, 2017

Conclusion

So, there you have it, qubits in a nutshell! They're the building blocks of the exciting world of quantum technologies. The ability to put qubits in a coherent superposition of states enables advantages that go beyond what is possible with classical bits.

The quantum world is truly fascinating, isn't it? We are just merely discussing a single fundamental unit that can perform numerous wonders, imagine what we can achieve if we delve further into this realm

(what if!!)