<?xml version="1.0" encoding="utf-8" standalone="yes"?><?xml-stylesheet href="/feed_style.xsl" type="text/xsl"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="https://www.rssboard.org/media-rss"><channel><title>Ia – El blog de Ignacio</title><link>https://www.igalvan.es/tags/ia/</link><description>Entradas de Ia en El blog de Ignacio</description><generator>Hugo -- gohugo.io</generator><language>es</language><copyright>Ignacio Galván Vitas</copyright><lastBuildDate>Wed, 18 Nov 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.igalvan.es/tags/ia/index.xml" rel="self" type="application/rss+xml"/><icon>https://www.igalvan.es/logo.svg</icon><item><title>MCP desde cero: qué es y qué problema resuelve</title><link>https://www.igalvan.es/posts/2026/mcp-desde-cero-que-es/</link><pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/mcp-desde-cero-que-es/</guid><description><![CDATA[<p>MCP es una sigla que veía pasar por todas partes sin saber bien qué había detrás. No había trabajado nunca con ello. Esta serie es lo que habría querido encontrar el primer día: empezar de cero, entender qué es, mirar el protocolo por dentro, montar un servidor de verdad sobre PostgreSQL, y después probarlo, romperle el diseño, atacarlo y publicarlo por HTTP.</p>
<p>Son siete entradas. Esta es la primera y es solo teoría, más un servidor de ocho líneas para que haya algo que ejecutar.</p>
<p>Una advertencia que me habría ahorrado una tarde: <strong>MCP ha cambiado mucho este año</strong>. La mayoría de tutoriales que encuentras en internet describen la versión anterior del protocolo (con un «apretón de manos» inicial y sesiones) y una API de Python que ya no existe con ese nombre. Esta serie usa la versión de protocolo <code>2026-07-28</code> y el SDK oficial de Python 2.3, que es lo vigente mientras escribo esto. Cuando algo difiera de lo que verás en otros sitios, lo digo.</p>
<p>El código está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-mcp" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-mcp</a>.</p>
<h2 id="el-problema-que-resuelve">El problema que resuelve <a class="ancla" href="#el-problema-que-resuelve" aria-label="Enlace a esta sección">#</a></h2>
<p>Un asistente de IA, por sí solo, solo sabe lo que sabe. No ve tu base de datos, ni tus ficheros, ni tu sistema de tickets. Para que pueda mirarlos (o hacer algo en ellos) alguien tiene que escribir la integración.</p>
<p>Sin un estándar, cada aplicación con un modelo necesita una integración propia con cada sistema: si hay M aplicaciones y N sistemas, son M × N trabajos. Si te dedicas a bases de datos esto te suena: es el problema que resolvieron ODBC y JDBC. Cada aplicación habla un protocolo común con un <em>driver</em>, y cada base de datos tiene su driver. Pasas de M × N a M + N.</p>
<p>MCP (<em>Model Context Protocol</em>) es eso mismo para asistentes de IA. Lo creó Anthropic y hoy se desarrolla como un proyecto abierto, con <a href="https://modelcontextprotocol.io/docs/2026-07-28/learn/architecture" target="_blank" rel="noopener">especificación pública</a>, SDK en varios lenguajes y un proceso de propuestas de cambio. Si has usado un editor con autocompletado, la otra comparación útil es con el <em>Language Server Protocol</em>: mismo planteamiento (un protocolo estándar entre el editor y los servidores de cada lenguaje) y, de hecho, también va sobre JSON-RPC.</p>
<h2 id="los-tres-actores">Los tres actores <a class="ancla" href="#los-tres-actores" aria-label="Enlace a esta sección">#</a></h2>
<p>Hay tres piezas, y conviene no mezclar los nombres:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span> host (la aplicación con el modelo)
</span></span><span style="display:flex;"><span> ├── cliente MCP 1 ── stdio ──▶ servidor A   (un proceso en tu máquina)
</span></span><span style="display:flex;"><span> ├── cliente MCP 2 ── stdio ──▶ servidor B   (otro proceso en tu máquina)
</span></span><span style="display:flex;"><span> └── cliente MCP 3 ── HTTP  ──▶ servidor C   (remoto)</span></span></code></pre></div>
</div>
<ul>
<li><strong>Host</strong>: la aplicación donde vive el modelo. Un editor, un asistente de escritorio, una herramienta de línea de comandos, o un programa tuyo.</li>
<li><strong>Cliente MCP</strong>: la parte del host que habla el protocolo. El host crea <strong>uno por cada servidor</strong> al que se conecta; cada cliente mantiene su conexión con su servidor.</li>
<li><strong>Servidor MCP</strong>: un programa que ofrece capacidades. Eso es lo que vamos a escribir.</li>
</ul>
<p>«Servidor» aquí no quiere decir «máquina remota»: un servidor MCP puede ser un proceso que el host lanza en tu propio equipo. Que sea local o remoto depende solo del transporte, que veremos en un momento.</p>
<h2 id="qué-ofrece-un-servidor-tres-cosas">Qué ofrece un servidor: tres cosas <a class="ancla" href="#qu%c3%a9-ofrece-un-servidor-tres-cosas" aria-label="Enlace a esta sección">#</a></h2>
<p>Un servidor puede ofrecer tres tipos de cosas. La diferencia entre ellas no es técnica sino de <strong>quién decide usarlas</strong>, y es la mejor forma de recordarlas:</p>
<table>
  <thead>
      <tr>
          <th>Qué</th>
          <th>Para qué sirve</th>
          <th>Quién decide usarlo</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><strong>Tool</strong> (herramienta)</td>
          <td>Una función que el modelo puede llamar: buscar usuarios, crear un evento, consultar un pedido.</td>
          <td>El <strong>modelo</strong></td>
      </tr>
      <tr>
          <td><strong>Resource</strong> (recurso)</td>
          <td>Datos de solo lectura con una dirección (URI): un fichero, el esquema de una base de datos, una ficha.</td>
          <td>La <strong>aplicación</strong></td>
      </tr>
      <tr>
          <td><strong>Prompt</strong></td>
          <td>Una plantilla de instrucciones con parámetros, para tareas que se repiten.</td>
          <td>El <strong>usuario</strong></td>
      </tr>
  </tbody>
</table>
<p>Para traducirlo a vocabulario de APIs (a medias, como todas las traducciones): una herramienta se parece a un endpoint RPC con parámetros tipados y un resultado; un recurso, a un <code>GET</code> sobre una URI; y un prompt, a una macro. En la práctica las herramientas son lo que más se usa, y lo que ocupa casi toda la serie.</p>
<p>Lo que hace especial a una herramienta, frente a un endpoint, es <strong>quién la llama y cómo se entera de que existe</strong>. A un endpoint lo llama un programa que escribió una persona leyendo la documentación. A una herramienta MCP la llama un modelo, que se entera de que existe porque el servidor se lo cuenta en tiempo de ejecución: el nombre, una descripción en lenguaje natural y un esquema JSON de los parámetros. El modelo decide si le sirve y con qué argumentos. Esa descripción forma parte de la interfaz, y de ahí sale casi todo lo interesante de las entradas 5 y 6.</p>
<h2 id="cómo-viaja-por-debajo">Cómo viaja por debajo <a class="ancla" href="#c%c3%b3mo-viaja-por-debajo" aria-label="Enlace a esta sección">#</a></h2>
<p>El mensaje es siempre <a href="https://www.jsonrpc.org/" target="_blank" rel="noopener">JSON-RPC 2.0</a>: peticiones con un <code>method</code> y unos <code>params</code>, y respuestas con un <code>result</code> o un <code>error</code>. Hay dos transportes:</p>
<ul>
<li><strong>stdio</strong>: el host lanza el servidor como proceso hijo y le habla por la entrada y la salida estándar. Es lo normal para servidores locales, sin red y sin puertos.</li>
<li><strong>Streamable HTTP</strong>: peticiones <code>POST</code> a una URL (por convención, <code>/mcp</code>). Es lo que se usa para servidores remotos, con autenticación HTTP normal.</li>
</ul>
<p>Y, desde la versión de protocolo <code>2026-07-28</code>, <strong>MCP no tiene estado</strong>. Cada petición lleva dentro todo lo necesario para procesarla: la versión del protocolo y las capacidades del cliente, en un campo <code>_meta</code>. No hay un <code>initialize</code> inicial ni una sesión. Un cliente puede preguntar qué ofrece el servidor con una petición <code>server/discover</code>, pero es opcional.</p>
<p>Que no haya sesión tiene una consecuencia práctica que se aprecia en la última entrada: un servidor remoto se puede repartir entre varias réplicas con un balanceador cualquiera, sin pegajosidad. Con la versión anterior, un cliente abría una sesión y todas sus peticiones tenían que llegar al mismo sitio.</p>
<p>El SDK actual atiende los dos mundos: un cliente moderno usa el protocolo nuevo, y uno antiguo hace su <code>initialize</code> de siempre y también funciona. En la <a href="/posts/2026/mcp-a-mano-json-rpc/">siguiente entrada</a> lo veremos con mensajes escritos a mano.</p>
<h2 id="un-primer-servidor">Un primer servidor <a class="ancla" href="#un-primer-servidor" aria-label="Enlace a esta sección">#</a></h2>
<p>El SDK oficial de Python 2.x se instala con <code>pip</code> (necesita Python 3.10 o posterior):</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>ignacio@localhost:~/lab-mcp$ python3 -m venv .venv &amp;&amp; source .venv/bin/activate
</span></span><span style="display:flex;"><span>ignacio@localhost:~/lab-mcp$ pip install &#34;mcp[cli]&gt;=2,&lt;3&#34;</span></span></code></pre></div>
</div>
<p>Ojo con el <code>&lt;3</code>: lo que instala <code>pip install mcp</code> es la serie 2.x, y conviene fijar el límite superior para que una versión mayor no te rompa los ejemplos.</p>
<p>El servidor mínimo, con una sola herramienta:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># hola/hola.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> mcp.server <span style="color:#f92672">import</span> MCPServer
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>mcp <span style="color:#f92672">=</span> MCPServer(<span style="color:#e6db74">&#34;Hola&#34;</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@mcp.tool</span>()
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">sumar</span>(a: int, b: int) <span style="color:#f92672">-&gt;</span> int:
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;Suma dos números enteros.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> a <span style="color:#f92672">+</span> b
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">if</span> __name__ <span style="color:#f92672">==</span> <span style="color:#e6db74">&#34;__main__&#34;</span>:
</span></span><span style="display:flex;"><span>    mcp<span style="color:#f92672">.</span>run()</span></span></code></pre></div>
</div>
<p>Tres cosas, que se repetirán toda la serie:</p>
<ul>
<li><code>MCPServer(&quot;Hola&quot;)</code> crea el servidor. Ese nombre es el que verán los clientes. (Si has visto tutoriales con <code>FastMCP</code>, es el mismo concepto con otro nombre: en el SDK 2.x <code>FastMCP</code> ya no existe y se usa <code>MCPServer</code>.)</li>
<li><code>@mcp.tool()</code> convierte la función en herramienta. El <strong>nombre</strong> sale del nombre de la función, la <strong>descripción</strong> de la docstring y el <strong>esquema de los parámetros</strong> de las anotaciones de tipo. No hay que escribir ningún JSON Schema.</li>
<li><code>mcp.run()</code> arranca el servidor; por defecto, por stdio.</li>
</ul>
<p>Si lo ejecutas directamente se queda esperando mensajes por la entrada estándar, que no es muy interesante. Para hablar con él hace falta un cliente, y el SDK trae uno. Este lanza <code>hola.py</code> como proceso hijo, pregunta qué herramientas ofrece y llama a una:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># hola/cliente_hola.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> sys
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> anyio
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> mcp <span style="color:#f92672">import</span> Client, StdioServerParameters
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">main</span>() <span style="color:#f92672">-&gt;</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#75715e"># Lanza hola.py como proceso hijo y habla con él por stdin/stdout.</span>
</span></span><span style="display:flex;"><span>    params <span style="color:#f92672">=</span> StdioServerParameters(command<span style="color:#f92672">=</span>sys<span style="color:#f92672">.</span>executable, args<span style="color:#f92672">=</span>[<span style="color:#e6db74">&#34;hola.py&#34;</span>])
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">async</span> <span style="color:#66d9ef">with</span> Client(params) <span style="color:#66d9ef">as</span> client:
</span></span><span style="display:flex;"><span>        print(<span style="color:#e6db74">&#34;servidor:&#34;</span>, client<span style="color:#f92672">.</span>server_info<span style="color:#f92672">.</span>name, <span style="color:#e6db74">&#34;| protocolo:&#34;</span>, client<span style="color:#f92672">.</span>protocol_version)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">for</span> herramienta <span style="color:#f92672">in</span> (<span style="color:#66d9ef">await</span> client<span style="color:#f92672">.</span>list_tools())<span style="color:#f92672">.</span>tools:
</span></span><span style="display:flex;"><span>            print(<span style="color:#e6db74">&#34;herramienta:&#34;</span>, herramienta<span style="color:#f92672">.</span>name, <span style="color:#e6db74">&#34;-&#34;</span>, herramienta<span style="color:#f92672">.</span>description)
</span></span><span style="display:flex;"><span>            print(<span style="color:#e6db74">&#34;  parámetros:&#34;</span>, herramienta<span style="color:#f92672">.</span>input_schema[<span style="color:#e6db74">&#34;properties&#34;</span>])
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>        resultado <span style="color:#f92672">=</span> <span style="color:#66d9ef">await</span> client<span style="color:#f92672">.</span>call_tool(<span style="color:#e6db74">&#34;sumar&#34;</span>, {<span style="color:#e6db74">&#34;a&#34;</span>: <span style="color:#ae81ff">2</span>, <span style="color:#e6db74">&#34;b&#34;</span>: <span style="color:#ae81ff">3</span>})
</span></span><span style="display:flex;"><span>        print(<span style="color:#e6db74">&#34;resultado:&#34;</span>, resultado<span style="color:#f92672">.</span>structured_content)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>anyio<span style="color:#f92672">.</span>run(main)</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>ignacio@localhost:~/lab-mcp$ cd hola &amp;&amp; python cliente_hola.py
</span></span><span style="display:flex;"><span>servidor: Hola | protocolo: 2026-07-28
</span></span><span style="display:flex;"><span>herramienta: sumar - Suma dos números enteros.
</span></span><span style="display:flex;"><span>  parámetros: {&#39;a&#39;: {&#39;title&#39;: &#39;A&#39;, &#39;type&#39;: &#39;integer&#39;}, &#39;b&#39;: {&#39;title&#39;: &#39;B&#39;, &#39;type&#39;: &#39;integer&#39;}}
</span></span><span style="display:flex;"><span>resultado: {&#39;result&#39;: 5}</span></span></code></pre></div>
</div>
<p>El cliente ha descubierto la herramienta sin que se la hayamos descrito en ningún sitio: nombre, descripción y los dos parámetros enteros salieron de la función. Y el resultado vuelve como <code>{'result': 5}</code>: MCP envuelve en un objeto lo que no lo es.</p>
<h2 id="lo-que-mcp-no-es">Lo que MCP no es <a class="ancla" href="#lo-que-mcp-no-es" aria-label="Enlace a esta sección">#</a></h2>
<p>Para no esperar de él lo que no hace:</p>
<ul>
<li><strong>No decide cómo usa el modelo las herramientas.</strong> El protocolo solo define cómo se anuncian y cómo se llaman. Qué herramienta elige el modelo, con qué argumentos y cuándo, es cosa del modelo y del host. El servidor no controla eso.</li>
<li><strong>No es una capa de seguridad.</strong> El protocolo lleva cosas de autorización para servidores remotos, pero que un servidor sea MCP no lo hace seguro ni de fiar. Un servidor local es un proceso normal con tus permisos. De esto va la entrada 6.</li>
<li><strong>No es un framework de agentes.</strong> Un agente puede usar MCP para llegar a sus herramientas, pero MCP no orquesta nada.</li>
</ul>
<h2 id="dónde-estamos">Dónde estamos <a class="ancla" href="#d%c3%b3nde-estamos" aria-label="Enlace a esta sección">#</a></h2>
<p>Tenemos el vocabulario (host, cliente, servidor; herramientas, recursos, prompts), sabemos que va sobre JSON-RPC por stdio o HTTP, que ahora no tiene estado, y que un servidor mínimo son ocho líneas.</p>
<p>En la <a href="/posts/2026/mcp-a-mano-json-rpc/">siguiente entrada</a> quito el SDK de en medio y le hablo a este mismo servidor escribiendo los mensajes a mano, por stdio y por HTTP con <code>curl</code>. Es la forma más rápida de que el protocolo deje de parecer magia.</p>
<p>Para saber más, la <a href="https://modelcontextprotocol.io/docs/2026-07-28/learn/architecture" target="_blank" rel="noopener">descripción de la arquitectura</a> en la documentación oficial y la <a href="https://py.sdk.modelcontextprotocol.io/" target="_blank" rel="noopener">documentación del SDK de Python</a>.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_2701baec85c8552c.png"/></item></channel></rss>