IB
IT Busina
AI & Large Language Models

Why Every Developer Should Understand Anthropic's Model Context Protocol (MCP)

IT Busina
July 18, 2025
8 min read
Abstract representation of AI context management

In the rapidly evolving landscape of Large Language Models (LLMs), managing conversational context efficiently is paramount. As developers build more sophisticated AI applications, they often hit limitations related to token windows, structured data, and maintaining coherent, long-running interactions. This is where Anthropic's Model Context Protocol (MCP) steps in as a critical standard.

What is Anthropic's Model Context Protocol (MCP)?

Anthropic's Model Context Protocol (MCP) is a specification designed to standardize how applications interact with LLMs, particularly concerning the management and transfer of conversational context. It provides a structured way to represent and exchange information, ensuring that LLMs receive the most relevant and concise context for generating accurate and coherent responses.

Think of it as a common language for your application and the LLM to discuss what's important in a conversation, allowing the model to "remember" key details without being overwhelmed by irrelevant information or exceeding its context window limits.

Why is MCP Necessary?

  • Context Window Limitations: LLMs have finite context windows (the amount of text they can process at once). MCP helps summarize and prioritize information to fit within these limits.
  • Structured Data Handling: It provides mechanisms to pass structured data (like JSON objects, database query results, or user profiles) to the model in a way it can easily understand and utilize.
  • Reduced Hallucinations: By providing precise and relevant context, MCP can help reduce instances where LLMs generate factually incorrect or irrelevant information.
  • Improved Performance & Cost: Sending only necessary context reduces token usage, leading to faster responses and lower API costs.

How MCP Works (Simplified)

At its core, MCP defines a set of conventions for how context should be formatted and presented to an LLM. This often involves:

  • Summarization: Condensing past conversation turns or external documents into a brief, relevant summary.
  • Tool Use: Providing the model with descriptions of available tools (e.g., a search engine, a database query tool) and the necessary context to decide when and how to use them.
  • State Management: Passing explicit state variables or user preferences that the model should consider.

Implementing MCP: A C# Server Example

For C# developers, building an MCP server involves setting up a host that can expose tools to an LLM. This typically uses the `ModelContextProtocol.Server` library to define and register your tools, and `Microsoft.Extensions.Hosting` to manage the application lifecycle.

Below are two key C# files demonstrating a basic MCP server setup that exposes a Jira search tool.

`Program.cs` - Server Setup and Dependency Injection

This file configures the host, sets up logging with NLog, and registers the MCP server with a standard I/O transport. It also demonstrates how to inject a `JiraService` with configuration from environment variables.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using NLog;
using NLog.Extensions.Logging;
using NLog.Config;
using NLog.Targets;
using System;

// Programmatic NLog configuration with log file path from environment variable (inline)
LogManager.Configuration = new LoggingConfiguration
{
    Targets = { new FileTarget("logfile") { FileName = Environment.GetEnvironmentVariable("LOG_FILE") ?? "logs/app.log", CreateDirs = true } },
    Rules = { new LoggingRule("*", LogLevel.Info, LogManager.Configuration.FindTargetByName("logfile")) }
};

// Create a host builder with empty settings
var builder = Host.CreateEmptyApplicationBuilder(null);

// Configure logging to use NLog
builder.Services.AddLogging(logging =>
{
    logging.ClearProviders();
    logging.SetMinimumLevel(LogLevel.Information);
    logging.AddNLog();
});

builder.Services.AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();

// Register JiraService with API version and connection details from environment variables
builder.Services.AddSingleton<JiraService>(sp =>
{
    var jiraHost = Environment.GetEnvironmentVariable("JIRA_HOST") ?? throw new InvalidOperationException("JIRA_HOST environment variable is not set.");
    var jiraUser = Environment.GetEnvironmentVariable("JIRA_USER");
    var jiraToken = Environment.GetEnvironmentVariable("JIRA_TOKEN") ?? throw new InvalidOperationException("JIRA_TOKEN environment variable is not set.");
    var jiraAuthType = Environment.GetEnvironmentVariable("JIRA_AUTH_TYPE")?.ToLower() ?? "bearer";
    var apiVersion = Environment.GetEnvironmentVariable("JIRA_API_VERSION") ?? throw new InvalidOperationException("JIRA_API_VERSION environment variable is not set.");
    
    return new JiraService(jiraHost, jiraUser, jiraToken, jiraAuthType, apiVersion);
});

var app = builder.Build();

await app.RunAsync();

`Tools.cs` - Defining an MCP Tool for Jira Search

This file defines a static class `Tools` with an `McpServerToolType` attribute, making its methods discoverable by the MCP server. The `Search` method demonstrates how to create a tool that takes parameters (like JQL, pagination, and fields) and uses a `JiraService` to perform a search.

using common;
using jira;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Protocol;
using ModelContextProtocol.Server;
using System.ComponentModel;
using System;

namespace jira
{
    [McpServerToolType]
    public static class Tools
    {
        [McpServerTool, Description("Search JIRA tickets (tasks, stories, defects, etc.) based on JQL (Jira Query Language).")]
        public static async Task<string> Search(
            JiraService jiraService,
            ILogger<Tools> logger,
            [Description("The Jira Query Language.")] string jql,
            [Description("The index of the first ticket to return (pagination). Optional.")] int? startAt = 0,
            [Description("The maximum number of tickets to return (pagination). Optional. Min 1, Max 1000. Default 10. When user asks for total number of tickets, this parameter is ignored.")] int? maxResults = 10,
            [Description("Comma-separated list of fields to include in the response. Optional.")] string? fields = null,
            [Description("Comma-separated list of entities to expand. Optional.")] string? expand = null)
        {
            if (startAt.HasValue && startAt.Value < 0)
                throw new ArgumentOutOfRangeException(nameof(startAt), "startAt must be non-negative.");
            if (maxResults.HasValue && (maxResults.Value < 1 || maxResults.Value > 1000))
                throw new ArgumentOutOfRangeException(nameof(maxResults), "maxResults must be between 1 and 1000.");

            return await logger.ExecuteAndLog(nameof(Search), async () =>
            {
                return await jiraService.SearchAsync(jql, startAt, maxResults, fields, expand);
            });
        }
    }
}

`JiraService.cs` - Jira API Client

This class provides the core functionality for authenticating and making requests to the Jira API, specifically for searching tickets. It handles different authentication types (Basic and Bearer) and API versions.

namespace jira
{
    public class JiraService
    {
        private readonly HttpClient _httpClient;
        private readonly string _apiVersion;

        public JiraService(string jiraHost, string? jiraUser, string jiraToken, string jiraAuthType, string apiVersion)
        {
            if (apiVersion != "2" && apiVersion != "3")
                throw new InvalidOperationException($"JIRA_API_VERSION must be '2' or '3'. Current value: '{apiVersion}'");

            _apiVersion = apiVersion;

            _httpClient = new HttpClient
            {
                BaseAddress = new Uri(jiraHost)
            };
            _httpClient.DefaultRequestHeaders.UserAgent.Add(new System.Net.Http.Headers.ProductInfoHeaderValue("jira-mcp", "1.0"));
            _httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
            _httpClient.DefaultRequestHeaders.Authorization = (jiraAuthType?.ToLower() ?? "bearer") switch
            {
                "basic" => string.IsNullOrEmpty(jiraUser)
                    ? throw new InvalidOperationException("JIRA_USER environment variable must be set for basic authentication.")
                    : new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{jiraUser}:{jiraToken}"))),
                "bearer" => new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", jiraToken),
                _ => throw new InvalidOperationException($"Unknown JIRA_AUTH_TYPE: {jiraAuthType}. Supported values are 'basic' or 'bearer'.")
            };
        }

        public async Task<string> SearchAsync(string jql, int? startAt = 0, int? maxResults = 10, string? fields = null, string? expand = null)
        {
            var queryParams = new List<string> { $"jql={Uri.EscapeDataString(jql)}" };
            if (startAt.HasValue)
                queryParams.Add($"startAt={startAt.Value}");
            if (maxResults.HasValue)
                queryParams.Add($"maxResults={maxResults.Value}");
            if (!string.IsNullOrWhiteSpace(fields))
                queryParams.Add($"fields={Uri.EscapeDataString(fields)}");
            if (!string.IsNullOrWhiteSpace(expand))
                queryParams.Add($"expand={Uri.EscapeDataString(expand)}");

            // Use the API version from the environment variable
            var endpoint = $"/rest/api/{_apiVersion}/search?{string.Join("&", queryParams)}";

            var json = await _httpClient.GetStringAsync(endpoint);
            return json;
        }
    }
}

Benefits of Adopting MCP

By embracing a structured approach like MCP, development teams can unlock significant advantages:

  • Improved LLM Reliability: Models receive consistent, high-quality context, leading to more predictable and accurate outputs.
  • Scalability: Efficient context management allows applications to handle more complex and longer conversations without hitting performance bottlenecks.
  • Easier Debugging: A standardized protocol makes it simpler to trace how context is being passed and identify issues.
  • Future-Proofing: Adhering to a protocol makes your application more adaptable to future LLM advancements and changes.

Conclusion

Understanding and implementing Anthropic's Model Context Protocol is no longer just a niche skill; it's becoming a fundamental requirement for building robust, scalable, and intelligent AI applications. For CTOs, engineering managers, and senior developers, investing in this knowledge within your teams will pay dividends in the quality, efficiency, and innovation of your LLM-powered products. Embrace MCP, and empower your AI to truly understand and respond within its context.