What is the Model Context Protocol (MCP)?

Definition

The Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI models communicate with external tools, data sources, and services. MCP provides a standardized interface that allows an AI assistant or agent to connect to file systems, databases, APIs, and other resources through "MCP servers" — without requiring custom integration code for each data source.

MCP was open-sourced by Anthropic in November 2024 and has since been adopted by a growing ecosystem of tools, IDE plugins, and AI services.

Why MCP Exists

Before MCP, integrating an AI assistant with external tools required custom code for each combination of AI model and tool. A developer building an AI assistant that could read files, query a database, and call an API had to implement three separate integrations — and repeat the work for every new AI model or tool they added.

MCP solves the N×M integration problem. With MCP, each tool implements the MCP server interface once. Each AI client implements the MCP client interface once. The result: any MCP-compatible AI can connect to any MCP-compatible tool without additional integration work.

How MCP Works

MCP Servers

An MCP server is a process that exposes resources and tools through the MCP protocol. Examples: a file system MCP server that allows an AI to read and write files; a database MCP server that allows SQL queries; a GitHub MCP server that exposes repository operations.

MCP Clients

An MCP client is an AI application (Claude Desktop, VS Code Copilot, Cursor) that connects to MCP servers. The client discovers what tools and resources each server exposes and presents them to the AI model as available capabilities.

MCP Primitives

MCP defines three core primitives that servers can expose:

• Tools — functions the AI can call with parameters (execute a SQL query, open a pull request, read a file)
• Resources — data the AI can read (a file, a database record, a webpage)
• Prompts — predefined prompt templates that users can invoke

MCP in Agentic Workflows

MCP is particularly valuable for agentic systems — AI agents that take multi-step actions to accomplish goals. An agent working on a code governance task might need to: read source files, run a linter, query a CVE database, create a pull request, and update a ticket. Each of these operations can be exposed through MCP servers, giving the agent the full toolkit it needs through a single, standardized interface.

Security Considerations

MCP servers have access to real systems — file systems, databases, APIs. Security considerations:

• Principle of least privilege — servers should expose only the minimum capabilities required
• Authentication — MCP connections should require authentication for sensitive resources
• Permission scoping — clients should be explicit about what permissions they are granting
• Audit logging — all MCP tool calls should be logged for security review
• Prompt injection risk — malicious content in resources read by MCP can attempt to inject instructions

Connection to Autonomous Code Governance

MCP is part of the infrastructure layer that makes autonomous code governance possible. Hydra uses MCP-compatible integrations to connect to source control (GitHub, GitLab), CI systems, ticket trackers (Jira, Linear), and package vulnerability databases. By standardizing on MCP for tool access, Hydra can integrate with new data sources and services without custom development — keeping the governance pipeline extensible as the ecosystem evolves.