MCP Core Architecture: Server, Client, and Host

Contenido del curso

Introducción a MCP

Conceptos basicos de MCP

MCP avanzado

Integrando tu MCP con un agente

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:004:52

MCP Core Architecture: Server, Client, and Host

Curso de MCP con Microsoft Azure

Clase 2 de 22

Clase 2 / 22

Comentarios (18)18 comentarios

Lender Lucas

Hace un año

Jose Ever Muñoz Muñoz

Andres Insuasty

David Herrera

sebastián García

Juan Carlos Quishpe

Miller Hurtado Espitia

Hace un año

William Schnaider Torres Bermon

Hace un año

Sander Álvarez Zuluga

Hace 8 meses

Jorge Ivan Meza

Hace un año

andres reyes

Hace un año•editado

Amin Espinoza

Profesor

Hace un año

Abc Def

Hace un año

Amin Espinoza

Profesor

Hace un año

Leonardo Escobar Heredia

Hace un año

Pedro Jesus Hincapie Garcia

Hace un año

William Schnaider Torres Bermon

andres reyes

andres reyes

andres reyes

William Schnaider Torres Bermon

Hace un año

William Schnaider Torres Bermon

Hace un año

William Schnaider Torres Bermon

Hace un año

William Schnaider Torres Bermon

Hace un año

Juan Carlos Quishpe

Hace un año

Recursos

If you want to build with the Model Context Protocol without getting tangled in language specifics, you need to lock down its core architecture first. Understanding MCP servers, clients, and hosts turns coding in any language into a non issue, because the logic stays the same regardless of the stack you choose.

What are the three core pieces of the MCP protocol?

MCP runs on a triad: server, client, and host. Each one has a job, and confusing them is the fastest way to get stuck.

The server is the unifying piece. It is where everything you want to manage inside your MCP lives and gets processed. Think of it as the engine room.

The client is not where you interact, even though the name suggests otherwise. Its job is to take the raw output from the server and compose it into something coherent. The server produces a response, the client structures it.

The host is the surface you actually touch. It is how you interact with your MCP, and in most real workflows it ends up being an IDE like VS Code, Visual Studio, or Eclipse.

What is an MCP server? It is the central component that receives requests, searches across its connected sources, and produces a raw response that the client will later format for the user.

Which information sources can an MCP server integrate?

A server is only as useful as the sources it can reach. In MCP, there are four types of inputs you can plug in, and a single server can handle any combination of them.

Contextual information: data coming from an LLM or from the ongoing conversation with the server.
Knowledge sources: documents or links to third parties that act as reference material.
Local files: a more specific version of the previous source, tied to your own machine.
APIs or web services: external endpoints you call to pull the information you need.

This flexibility is what makes MCP powerful. You are not locked into one type of input, you compose the sources that fit your use case.

How does information flow inside an MCP?

The flow is linear, but each hop matters. Skip one and the response breaks.

How does the user request reach the server?

It starts with you writing a question. That question has to match the scope of the MCP, because MCPs are intentionally narrow in topic. If your active MCP is connected to Azure, you can ask how many resources you have deployed in your subscription. Asking about your GitHub account in that same MCP makes no sense, the server has no way to answer coherently.

Once the question is written, it travels to the client. The client extracts what it needs and forwards the request to the server.

How does the server decide which source to use?

Here is where MCP gets interesting. The server receives the question and, without you defining priorities or orchestrating the search, it scans the four sources available and picks the most relevant one to build the answer. You do not micromanage the routing, the protocol handles it.

The server then processes that information in a format that, honestly, is not human readable on its own. That is exactly why the next step exists.

Why does the client exist if the server already has the answer? Because the server returns data in a format that is not user friendly. The client transforms that raw output into readable text or whatever structure your app expects.

How does the response reach the user?

The server sends its raw result to the client. The client restructures it into something comprehensible, usually a text response, though it can take any shape your users need as long as it is readable.

Finally, the client passes the structured response to the host. The host, often your IDE, displays it to you as the end user. That pivot between the three pieces, server, client and host, is the loop you will work with every time you build with MCP.

What is the role of the host in MCP? The host is the interface where you read the final answer. It can be an application or an IDE like VS Code, and its only job is to present the structured response to the user.

Why does mastering these concepts simplify MCP coding?

Once the architecture clicks, writing the code is the easy part. The hard work is mental: knowing which piece does what, where the data flows, and why the client and server are split. With that map in your head, translating the design into Python, TypeScript, or any other language stops being a blocker.

Which of the four MCP sources do you think you will connect first in your own project? Drop your idea in the comments.

Parentesis grande, me dio curiosidad la camiseta de Amin, 😅. En resumen, los números binarios en decimal son:

01000001 (rojo) = 65
01001101 (verde) = 77
01001001 (azul) = 73
01001110 (para la 'N') = 78 --> Toco adivina, no se logra ver.

Si consideramos estos como códigos ASCII:

65 es 'A'
77 es 'M'
73 es 'I'
78 es 'N'

La secuencia de letras deletrea "AMIN"!, muy curioso y creativo, me muy buena la idea 😁💯🤝

Impactante!

Me sacaste de la duda!!! jajaja

Para los que no les quedo demasiado claro, dejo unas notas:

🔄 Los 3 Componentes Clave de MCP

🖥️ SERVIDOR

"El cerebro del sistema"

Función: Procesa todas las solicitudes y busca información
Acción: Recibe peticiones → Consulta fuentes → Genera respuestas
Analogía: Como un bibliotecario que busca en diferentes secciones

💻 CLIENTE

"El traductor intermedio"

Función: Hace de puente entre el usuario y el servidor
Acción: Toma pregunta del usuario → La envía al servidor → Recibe respuesta → La organiza
Analogía: Como un intérprete que traduce entre dos idiomas

📱 HOST

"La pantalla donde ves todo"

Función: La aplicación final donde interactúas
Acción: Muestra la información procesada al usuario
Ejemplos: VS Code, Visual Studio, Eclipse

Excelente! Gracías

El Message Control Protocol (MCP) conecta usuarios con modelos de lenguaje.

Funciona con tres componentes principales:

Servidor: Procesa la solicitud y busca información desde contexto, documentos, archivos o APIs.

Cliente: Recibe la respuesta del servidor y la hace comprensible.

Host: Muestra el resultado final al usuario (por ejemplo, en un IDE).

4 fuentes de información que puede usar el servidor:

Contexto: De conversaciones o LLM.

Fuentes de conocimiento: Documentos, enlaces, etc.

Archivos locales: Información directa desde el entorno.

APIs o servicios web: Para consultas externas.

El flujo es: Usuario pregunta → Cliente interpreta → Servidor responde → Cliente organiza → Host muestra.

Flujo de trabajo del MCP:

1 El usuario hace una pregunta relacionada al contexto del MCP.

2 El cliente interpreta la pregunta y la envía al servidor.

3 El servidor busca la mejor fuente de información y procesa la respuesta.

4 El cliente estructura la respuesta de forma comprensible.

5 El host muestra el resultado final al usuario.

El host en el contexto de MCP es el entorno donde interactúas con el sistema, y puede ser cualquier plataforma que soporte la integración, como aplicaciones web, IDEs o incluso interfaces de mensajería. Un canal de Slack o un chat de WhatsApp puede funcionar como host si se implementa correctamente la comunicación con el servidor y cliente de MCP. Sin embargo, la efectividad de esta integración depende de cómo se estructuren las interacciones y el manejo de la información.

How MCP Servers Work

MCP servers operate in the following way:

Request Flow:
1. A request is initiated by an end user or software acting on their behalf.
2. The MCP Client sends the request to an MCP Host, which manages the AI Model runtime.
3. The AI Model receives the user prompt and may request access to external tools or data via one or more tool calls.
4. The MCP Host, not the model directly, communicates with the appropriate MCP Server(s) using the standardized protocol.
MCP Host Functionality:
- Tool Registry: Maintains a catalog of available tools and their capabilities.
- Authentication: Verifies permissions for tool access.
- Request Handler: Processes incoming tool requests from the model.
- Response Formatter: Structures tool outputs in a format the model can understand.
MCP Server Execution:
- The MCP Host routes tool calls to one or more MCP Servers, each exposing specialized functions (e.g., search, calculations, database queries).
- The MCP Servers perform their respective operations and return results to the MCP Host in a consistent format.
- The MCP Host formats and relays these results to the AI Model.
Response Completion:
- The AI Model incorporates the tool outputs into a final response.
- The MCP Host sends this response back to the MCP Client, which delivers it to the end user or calling software.

Sander, 5 ejemplos de Servidor según sus fuentes: 1. Un conector de Azure (suscripciones), 2. Uno que lea archivos locales (PDF/TXT), 3. Una API de clima, 4. Un buscador web (SERP API) y 5. Una base de datos de documentos internos.

qué lenguajes de programación de utilizarán para las prácticas del curso

Porque la respuesta del servidor tiene que pasar por un LLM para obtener una respuesta estructurada? siento que si la respuesta pasa por un LLM puede truncarse? hay test o métricas que uno pueda crear para evitar esto?

Pasa por un LLM para que puedas obtener una respuesta humanamente entendible. De lo contrario recibirías una respuesta bien alocada que no podriamos entender tan fácil.

Justo hoy en el trabajo vi una demostración de un MVP para un chat que responde a preguntas sobre los clientes. Menos mal hay un curso para entender eso en mi lengua materna 😂

Jajajajaja

Sí, se puede implementar un sistema MCP que funcione como un chat similar a ChatGPT. La clave está en utilizar un modelo de lenguaje (LLM) en el servidor que procese las preguntas del usuario y genere respuestas. El cliente estructurará estas respuestas de manera comprensible, y el host presentará la información al usuario final. Esto permite crear interacciones conversacionales efectivas, aprovechando las capacidades de inteligencia artificial del MCP.

MCP:

Más que un protocolo, no es solo una serie de reglas; es el estándar que permite a tu software interactuar de manera fluida y nativa con la IA.

Piénsalo de esta forma:

Sin MCP, tu software tendría que ser adaptado manualmente para cada modelo de IA, lo que consume tiempo y recursos.

Con MCP, se establece un lenguaje común que garantiza que cualquier software compatible pueda "hablar" directamente con cualquier sistema de IA que también lo sea, sin necesidad de configuraciones especiales o traducciones complejas.

🌍 Real-World Use Cases for MCP

MCP enables a wide range of applications by extending AI capabilities:

Is there would be enhance of performance or user satisfactions if we added in middle of the layer those tooling?

Para lograr respuestas concisas que pasen por un LLM sin que los datos sean truncados, es clave estructurar y limitar la entrada al modelo. Utiliza prompts específicos y claros que dirijan la atención del LLM hacia la información más relevante, evitando así respuestas largas. Además, implementa un sistema de validación que filtre respuestas no deseadas, asegurando que solo se retornen datos útiles. La integración de un cliente que interprete y estructure adecuadamente la salida del LLM antes de presentarla al usuario también es esencial para mantener la claridad y precisión.

La pregunta fue: como podemos asegurarnos que la respuesta no sea truncada y que el modelo asegure que sean los datos de respuesta

🧱 High-Level MCP Architecture Overview

MCP follows a client-server model, where:

MCP Hosts run the AI models
MCP Clients initiate requests
MCP Servers serve context, tools, and capabilities

Key Components:

Resources – Static or dynamic data for models
Prompts – Predefined workflows for guided generation
Tools – Executable functions like search, calculations
Sampling – Agentic behavior via recursive interactions

💡 Why the Model Context Protocol (MCP) Is a Game-Changer

🔗 MCP Solves Fragmentation in AI Interactions

Before MCP, integrating models with tools required:

Custom code per tool-model pair
Non-standard APIs for each vendor
Frequent breaks due to updates
Poor scalability with more tools

✅ Benefits of MCP Standardization

🎯 Why Standardization in AI Matters

As generative AI applications become more complex, it's essential to adopt standards that ensure scalability, extensibility, maintainability, and avoiding vendor lock-in. MCP addresses these needs by:

Unifying model-tool integrations
Reducing brittle, one-off custom solutions
Allowing multiple models from different vendors to coexist within one ecosystem

Note: While MCP bills itself as an open standard, there are no plans to standardize MCP through any existing standards bodies such as IEEE, IETF, W3C, ISO, or any other standards body.

🔍 What Is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open, standardized interface that allows Large Language Models (LLMs) to interact seamlessly with external tools, APIs, and data sources. It provides a consistent architecture to enhance AI model functionality beyond their training data, enabling smarter, scalable, and more responsive AI systems.

La clase se centra en los componentes esenciales del protocolo MCP: servidor, cliente y host. El servidor genera respuestas basadas en preguntas del usuario, mientras que el cliente organiza y presenta estas respuestas de forma comprensible. El host es la interfaz donde interactuamos con el sistema. Se destacan cuatro fuentes de información que el servidor utiliza: información contextual, fuentes de conocimiento, archivos locales y APIs. La interacción fluye desde el usuario hacia el cliente, luego al servidor y finalmente regresa al cliente para ser presentada al usuario.

Introducción a MCP

Introducción a MCP

MCP Core Architecture: Server, Client, and Host

MCP Dev Environment Setup for Python

MCP Server Setup With Python and Inspector

Conceptos basicos de MCP

Four Core Blocks of Every MCP Server

Building an MCP Client That Talks to Your Server

Adding an LLM to Your MCP Client

STDIO vs SSE in MCP Servers

LLM Connected to a Local MCP Server

Testing MCP Servers Without a Browser

Deploying an MCP Server to Azure Container Apps

Using MCP Servers in VS Code Agent Mode

MCP avanzado

Query Azure Resources Directly From VS Code

Herramientas avanzadas de MCP para optimizar servidores y seguridad

GPT-4 Reading Local Files via MCP Server

Image Brightness Analysis with MCP and NumPy

How MCP Agents Remember Conversations

Enrutamiento de herramientas con MCP Server

Integrando tu MCP con un agente

Building a Web Search MCP Server with SERP API

Adding News, Products and Q&A Tools to MCP

Why MCP Docs Already Feel Outdated

MCP as the New Standard for AI Systems

MCP Core Architecture: Server, Client, and Host

Progreso del curso

Introducción a MCP

Conceptos basicos de MCP

MCP avanzado

Integrando tu MCP con un agente

Recursos

Recursos