Over the past year we have seen rapid evolution in how we build applications with large language models (LLMs) and AI agents. Each leap in abstraction has brought new challenges. To understand why the Model Context Protocol (MCP) matters, it helps to start with a clear definition and then walk through the journey that brought us here.

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is a standard protocol —created by Anthropic— that lets AI agents expose and consume tools in a decoupled way. An MCP Server publishes a set of capabilities (querying an API, reading documentation, creating a file) and any compatible agent uses them as an MCP Client, without having to integrate and maintain each tool on its own.

The result is a common language between LLMs, agents, and external systems: reusable, standardized capabilities that are easy to operate at scale. Below we walk through the journey that led to this standard.

The beginnings: LLMs without actions

It all started with LLMs. These models take an input (prompt) from the user and generate a response. They are very good at producing content based on the data they were trained on: writing an essay, summarizing a document, translating a text.

We soon ran into an obvious limit: LLMs only generate text, with no ability to execute actions in the real world.

Second stage: agents with tools

The next evolution was agents. They leverage the ability of LLMs to reason and generate instructions, but now with access to tools (external capabilities).

With this, agents can:

  • Query an API (for example, the SUNAT exchange rate).
  • Search the web (as Perplexity or ChatGPT do).
  • Create files or connect to third-party systems.

The LLM does not execute the action directly, but decides when to invoke a tool and builds the final response based on the result.

The problem: coupling between tools and agents

This was a major step forward, but it brought a challenge: agents were responsible for defining, maintaining, and integrating all of their tools.

Each agent ended up coupled to its own set of tools, which made reuse, maintenance, and standardization across projects and teams difficult.

The leap: MCP arrives

To solve this, Anthropic introduced the Model Context Protocol (MCP).

MCP defines a standard protocol that lets you expose tools (capabilities) to agents in a decoupled way:

  • You build an MCP Server that implements the actions (for example, creating a repo on GitHub or querying AWS documentation).
  • Agents act as MCP Clients, connecting to the servers via: stdio (standard stream) or shttp (streaming HTTP).

MCP servers don’t just expose tools, they also publish contextual information such as available prompts or capability descriptions. This way, an agent can dynamically decide what to use to respond to the user’s request.

Adoption across the ecosystem

In a short time, MCP has been widely adopted. A few examples:

For organizations, MCP means modularity:

  • Teams expose capabilities once and consume them from multiple agents.
  • They can build reusable MCP Servers and use them across multiple projects, simplifying maintenance and deployment.

MCP in action: Amazon Q CLI + GitHub

Let’s look at a practical example: configuring the GitHub MCP Server inside the Amazon Q CLI.

Prerequisites

Configuring the mcp.json file

Depending on the scope you need:

  • Global (all projects): ~/.aws/amazonq/mcp.json
  • Workspace only: .amazonq/mcp.json

Create the file with this content (replace the GitHub Personal Access Token):

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<your-access-token>"
      }
    }
  }
}

Usage

Run:

q chat

Inside Amazon Q you will see the configured tools, including the GitHub one. Now you can, for example, create a repository directly from your console without leaving the agent.

Conclusions

The Model Context Protocol (MCP) represents a paradigm shift:

  • It decouples agents and tools.
  • It establishes a common language between LLMs, agents, and external systems.
  • It enables the creation of reusable, secure tool ecosystems.

In other words, MCP takes us from agents with isolated tools to an interoperable ecosystem of capabilities, far better prepared to scale in real-world, enterprise environments.

How we apply this at Caleidos

In real-world client projects, MCP Servers become the backbone of corporate GenAI platforms: a shared layer of reusable capabilities that different business agents (customer service, sales, operations) can consume without duplicating logic.

Caleidos designs and implements these ecosystems as part of our Agentic AI on AWS service, including MCP Server architecture, integration with Bedrock, and agents in production operated 24×7 by Caleidos Lens©.

Want to talk through your use case? Let’s talk →