Model Context Protocol (MCP): Understand Core Concepts of MCP

-

The Model Context Protocol (MCP) is an open standard that allows AI applications to connect seamlessly with external tools, data sources, and workflows. You can consider it as a USB-C port for AI that lets AI applications to plug into existing applications those uses Databases, Files, etc. 

Technically, MCP can be defined as a protocol that is developed to standardize a mechanism using which various AI models e.g. ChatGPT, Cloude, etc. interact with an external system. The purpose of MCP is to ensures that the AI can access real-time, contextually relevant data and perform tasks securely. 

Why does MCP Really Matters?

An existing AI Systems do face following challenges:

  • Fragmented APIs: 
    • Since each and every Application has its own style of integration e.g. REST, SOAP, GraphQL, RPC, there is no standard mechanism exist for the client application to interact with it. These results into a technical glitch where client need to implement several connectors to integrate with such an application. The MCP provides a standard for such integration.          
  • Context Gaps:
    • Many AI models are trained on large datasets but probably these datasets don’t continuously update and hence the information aka the knowledge is frozen at a point in time. As a result of this the received answers from such outdated datasets may be incorrect or misleading.
    • In case of the need for the live-data e.g. News, Stock-Information, etc. answers became stale and they may result into the wrong interpretation by the end-user.
    • Since latest information about an event or users' profile information is not fed to AI, the information context will be incomplete that result into frustration. E.g. Imagine that your search-engine is still showing old irrelevant information.
  • Enterprise Hesitation:
    • When the data is not updated or it is outdated, it results into great confusion about any decision making and hence enterprise customers/users will start running away from the system.
The one-stop solution for these challenges is to use MCP. The MCP has following great offerings:

  • Unified Connectivity:
    • Instead of writing custom connectors for each app e.g. Slack, Salesforce, Google Calendar, etc., the Model Context Protocol (MCP) defines a common way for agents to interact with any system.
    • MCP acts as a translator between the agent and the app, that offers an abstract layer so that the agent doesn’t need to know the application's unique API quirks.
    • Once an app supports and adapts MCP, any AI agent that understands MCP can use it immediately without much extra coding required. This offers Plug-and-play integration.
  • Real-Time Access:
    • Since AI can connect directly to various sources like calendars, databases, emails, or APIs to fetch the most current information.
    • This helps the AI to tailor answers based on what’s happening currently instead of guessing or using outdated knowledge.
    • As the data changes immediately, it is available to AI system, this increases the synchronization.
  • Simplified Integration:
    • Instead of writing unique code for every service e.g. Slack, Salesforce, Google Calendar, etc. developers save time by avoiding repetitive, service-specific integrations.
    • The same agent logic works across multiple apps without modification.
    • There is no need to reinvent authentication, data parsing, or error handling for each new service.
    • New apps can be added quickly since the integration pattern is already established. 
  • Scalability:
    • MCP provides an easy addition of new tools or services without rewriting code.
    • With MCP protocol, every tool speaks the same language, so adding one doesn’t require rewriting agent logic.
    • Teams don’t need to constantly maintain or refactor code when scaling integrations.
  • Security:
    • This offers a controlled and permission-based access to sensitive data of the application.
    • The AI agents don’t get unrestricted entry into all the apps or data. Instead, they only access what is explicitly allowed to AI Agents.
Core Components of Model Context Protocol

Following are major core components of MCP:
  • MCP Host:
    • The MCP host is an AI application that provides the environment for executing AI-based tasks while running the MCP client. 
    • The major role of the Host is to interact with various AI tools e.g. Cloude Desktop, ChatGPT to create AI-assisted contents creation to enable smooth communication with external services,
    • The major responsibility of MCP host is to host the MCP Client so that it can establish smooth communication with the MCP Server,     
  • MCP Client
    • In the MCP Host–Client–Server architecture, the MCP client's role is to act as a mediator component within the host environment that maintain a one-to-one communication link with its corresponding MCP server. 
    • We can visualize the MCP client as a representative of the MCP host. The client is responsible to initiate the request to the MCP Server and query to the functions exposed by the MCP Server. 
    • In real AI agent implementation, the prompt passed to the Host will be used by the client to generate the data schema. This schema is the JSON form is send to the MCP Server for the further processing.  
    • This design enables the host to seamlessly access and utilize external functionalities provided by MCP servers.
    • The MCP client communicates using the transport layer with MCP servers, facilitating secure, reliable data exchange and smooth interaction between the host and external resources.
  • MCP Server:
    • This is the most important part of the core components. This enables the MCP host and client to access external systems and execute various operations, by offering the following three core capabilities:
      • Tools:
        • They are active functions exposed by the MCP Server.
        • These functions contain logic to perform various operations like Upload file to file server, Query to database, send message to a messaging system, create an event in calendar, etc. 
        • Each of this tool has name, description and input/output format. The client query to these functions by sending data and the processed data by these functions is sent back to the client.  
      • Resources:
        • In a simple word, resources are passive data sources like File System, Database schema, etc.
        •  Resources provide access to structured and unstructured datasets that the MCP server can expose to AI models.
        • Datasets may come from various sources e.g. local storage, databases, or cloud platforms. When an AI model requests specific data, the MCP server retrieves and processes the relevant information, this enables the model to make data-driven decisions.
        • Resources are used by AI system to understand which folder to read to access information from files, what is the schema for tables to whether the table and column exists or not, etc.
      • Prompts:
        • A prompt is a template or instruction that set behaviour of AI.
        • A prompt guides the AI that "What to do?". E.g. Query to Database, write data to database, generate a bug report, etc.  
  • Transport Layer:
    • The transport layer is used to ensures the secure, bidirectional communication, that allows a real-time interaction and efficient data exchange between the host environment and external systems.
    • The transport layer helps send the first request from the AI to the server, delivers back what the server can do, and keeps the AI updated with any new changes or messages.
      • It’s like a messenger system that:
        • Carries the AI’s questions to the server
        • Brings back answers and available tools
        • Sends updates if anything changes later

Figure 1 explains core components in details.


Figure 1: General Core Components of MCP 

Important uses of MCP
 
MCP is not just useful, it’s designed to be the backbone of AI agent creation, making agents more capable, reliable, and enterprise ready.

Some of the real-world uses are as follows:
  • Improvising Enterprise Productivity:
    • MCP powered AI assistant can check the Outlook calendar to find free slot to schedules meetings automatically.
    • It can access emails and analyze them to handle tasks.
  • Software Development Productivity:
    • MCP powered AI Agent can file bug report, create issues, review pull requests and manage repositories on GitHub.
  • Productivity in Customer Support:
    • MCP Powered AI agent can read the prompt for placing orders, analyze the customer feedback to raise the support ticket based on the feedback.
  • Data Analytics:
    • By interactive with database / data stores, the AI Agent can analyze data and generate reports,
    • This is the most useful user story for provide real-time data analysis for the end-user.
  • Improve Team Management:
    • The AI agent can interact with Team Communication tools like Teams, Slick, etc to manage posts, reminders, etc.
  • File Management:
    • The AI Agent can interact with File System to retrieve contents from the File and generate summary and analysis from it.
These use cases matter for the following purposes:
 
  • Efficiency: MCP Powered AI Agents cuts down repetitive tasks.
  • Scalability: AI Agents works across many apps without custom integrations.
  • Contextual Intelligence: AI agents act with live, relevant data instead of outdated training sets.
Conclusion: The MCP can be used for creating AI Agents as to provide AI capabilities with an existing application without any considerable coding-overhead. 

         

Popular posts from this blog

ASP.NET Core 8: Creating Custom Authentication Handler for Authenticating Users for the Minimal APIs

-
Image
The ASP.NET Core is the superb technology for building modern web apps. One of the best features of ASP.ET Core is the ease of security implementation and its customization as per the application requirements. The Identity Object model of ASP.NET Core provides extensive customization to the developers so that they can implement the security logic as per the application's requirements where the Identity can be verified against the On-Premises and/or Cloud stores where the Users' credentials are kept.  In this article we will see an implementation of the custom Authentication Handler to handle the authorization of the request to the Minimal APIs. The Figure 1 provides an idea of the implementation Figure 1: The Authentication Handlers in ASP.NET Core Minimal APIs To implement custom authentication handler, we will be using the following classes: AuthenticationSchemeOptions:   This class is used to set the scheme for the authentication calls. The request to the API will be f...
Read more

Uploading Excel File to ASP.NET Core 6 application to save data from Excel to SQL Server Database

-
Image
Recently, while conducting a session on ASP.NET Core 6, my client raised a query regarding uploading excel files to the ASP.NET Core MVC application and then further saving data from excel to the SQL Server Database table. I gave him the solution and then thought to write a post on it. As we all know, the Excel Workbook is one of the most heavily used files to save data. But to persist data it is recommended that it should be stored in an SQL Server database.  If the data is stored in an SQL Server database it can be queried easily.  Figure 1, explains an implementation of the application which we are going to discuss in the article. Figure 1: The ASP.NET Core That accepts Excel files and then further store data from Excel Files in SQL Server Database The   ExcelDataReader.DataSet Library To read excel files in ASP.NET Core applications, we need to use the ExcelDataReader.DataSet package. This is a lightweight and fast library for reading Excel files in .NET applications....
Read more

ASP.NET Core 7: Using PostgreSQL to store Identity Information

-
Image
In this article, we will see using the PostgreSQL database to store the ASP.NET Identity information in it. If the ASP.NET Core application is using PostgreSQL database instead of SQL Server database then we can use it to store application user and role information. This article is a simple implementation of identity in ASP.NET Core using PostgreSQL. To create a database and tables for storing ASP.NET Identity information, we use classes like IdentityUser, IdentityRole, etc. The EntityFrameworkCore Code-First approach is used to create a database and tables.  Step 1: Open Visual Studio 2022 and create a new ASP.NET Core API project. Name this project as Core_API_Postgre_Identity. To use Identity classes and PostgreSQL add the following packages to the project Microsoft.AspNetCore.Identity This package is needed to use IdentityUser and IdentityRole classes Microsoft.AspNetCore.Identity.EntityFrameworkCore This package is needed to use IdentityDbContext class. This class is used...
Read more