DEV Community: Cecy Geraldo

🧠 What’s the deal with MCP? And why you should start exploring it now

Cecy Geraldo — Sun, 27 Jul 2025 02:25:21 +0000

A couple of weeks ago, I started hearing more and more about something called Model Context Protocol (MCP). Actually, the first thing I saw was a TikTok by ChicaPython, and from that I kind of understood that MCP was like an API… but for communicating with LLMs (Large Language Models) 🤯.

Then I started googling and found the official documentation, with several readings on the architecture of the protocol. From there, with some examples and tutorials using Claude, I jumped into the practical side.

And here’s what makes it powerful: MCP is a standard protocol, declared in November 2024 (so yeah, pretty recent). And being a standard means it’s here to stay. From now on, this is how we communicate with LLMs, not just to consume services like when we used the Gemini API to create an agent. We now use MCP to boost communication and increase model operability.

With MCP, you can create an agent and, through an MCP server, give it specific permissions to perform concrete actions. For example, you can authorize an agent to read and write files in a local folder—it can pull information from there and save outputs too. And the best part is, thanks to the Open Source community, there are already tons of MCP servers available:

To connect with GitHub and have the agent build a Pull Request for you (like Jules, the copilot presented by Google at this year’s I/O),
To read a database,
Or to automate tasks like checking issues, generating reports, and much more.

🟡 Side note: As with anything powerful, use it with good judgment. Review carefully what permissions you’re giving before using third-party MCPs. You might be exposing more than you think. (Let’s bring back the classic phrase: “With great power comes great responsibility.”)

💡 What I loved the most

You don’t need a powerful machine, weird programs, or to learn a brand-new language. None of that.

You can work locally, run the MCP inspector, and test what you’re building in TypeScript, for example or any compatible language (I’ll drop them at the end of the article). You can even configure an existing MCP with a simple JSON file. Easy-peasy.

You can also test the tools you develop directly integrated into Claude, for free.

That’s how I created my first MCP server in TypeScript, following a tutorial by Midu. I used a local viewer to test tools, activated developer view in Claude to test what I was building, automated GitHub pull requests using @modelcontextprotocol/server-github, and managed to create an agent connected to a weather API that gave me real-time weather for any city I asked about. I also accessed the local file system to read and save files in a controlled way.

The most exciting part? Just with the ability to read and write files, you can give your model context with information in directory X and save the synthesized results of your queries to directory Y.

All under control. No hallucinations. Clear steps.

All from your local machine!

Here’s an example of how the MCP config looks when enabling access to your file system, like giving it permission to read your Desktop. When you add this tool to Claude, you can interact with the agent, ask it to read files on the Desktop, give you outputs based on them, and save the results to files.

👀 So, why should you start exploring it too?

Not just because it’s here to stay, and not just for the hype. This goes deeper.

You should start exploring MCP because:

If you feel like you’re late: today is literally the earliest you can start.
You don’t need any Machine Learning background.
You don’t need to learn a new language: MCP has official SDKs in TypeScript, Python, Java, Kotlin, and C#—so chances are you can already start with what you know (and if not, maybe it’s the perfect excuse to learn something new through a fun project).
You’ll unlock creative thinking: playing with MCP will spark all kinds of ideas to connect tools and explore new possibilities.

Also: MCP is model-agnostic. You can use it with Claude, ChatGPT, Gemini, or whatever comes next.

The model itself isn’t the key. What matters is the context you provide, the instructions, the tools you expose, and the permissions you define.

🎮 Exploring is super easy

A single idea bouncing in your head is enough. You don’t need a huge project to get started.

You can wrap an API you already use, build a simple automated flow, or just play around with local files.

And if something feels uncomfortable along the way (like granting permissions, understanding what the model sees or can execute), that’s okay.

That discomfort teaches you too. Questioning boundaries is part of the journey and it’s how we shape more responsible AI.

🧭 100% recommended links to get started

Here are a few useful links if you want to begin (just like I did 👀):

MCP won’t do everything for you, but it gives you the power to decide how and what to build.

Have you tried it yet? If not, I hope this little blog post inspires you to start.

You could start by reading files from your local system, automating a GitHub pull request, connecting to a weather API, or even building a small tool to organize your notes.

It’s not about how big the project is, it’s about the curiosity to explore ✨

🧠 ¿Qué es el famoso MCP? Y por qué deberías estar explorándolo ya

Cecy Geraldo — Mon, 21 Jul 2025 03:52:10 +0000

Hace un par de semanas empecé a escuchar cada vez más sobre algo llamado Model Context Protocol (MCP). De hecho, lo primero que vi fue un video en TikTok de ChicaPython, y lo que entendí a primeras fue que MCP era una especie de API… pero para comunicarse con LLMs (Large Language Models) 🤯.

Después me puse a googlear y encontré esta documentación oficial, con varias lecturas sobre la arquitectura del protocolo. Desde ahí, con algunos ejemplos y tutoriales usando Claude, empecé la parte práctica.

Y lo potente de esto es que MCP es un protocolo de comunicación estándar, declarado en noviembre de 2024 (sí, relativamente nuevo). Y al ser un protocolo estándar, significa que llegó para quedarse. Su objetivo es que los LLMs puedan interactuar con el mundo real: ejecutar acciones, conectarse a servicios externos y recibir información en tiempo real. Y lo mejor: agnóstico del modelo.

Desde ahora, nos comunicamos de esta manera con los LLMs, y no solo para consumir servicios como cuando usábamos la API de Gemini para crear un agente. Ahora usamos MCP para potenciar la comunicación y aumentar la operabilidad del modelo.

Casos de uso prácticos

Con esto, podemos crear un agente y, a través de un MCP server, darle permisos específicos para que ejecute acciones concretas. Por ejemplo, podemos autorizar la lectura y escritura del agente en una carpeta local para que obtenga información desde ahí y guarde los outputs en un archivo. Y lo mejor es que gracias a la Comunidad Open Source, ya existen muchos MCP servers disponibles, acá te dejo algunos ejemplos de uso:

Para conectarte con GitHub y que el agente te arme un Pull Request (como Jules, el copiloto que presentó Google en el I/O de este año)
Para leer una base de datos
O para automatizar tareas como revisar issues, generar reportes y mucho más

🟡 Side note: como con todo lo poderoso, hay que tener criterio. Revisa bien qué permisos estás entregando antes de usar MCPs de terceros. Puedes estar exponiendo más de lo que imaginas. (Apliquemos la frase estrella "Un gran poder significa una gran responsabilidad")

Lo que más me gustó 💡

Lo que más me sorprendió fue lo accesible que es: no necesitas una máquina muy potente, ni programas raros, ni aprender un nuevo lenguaje recién lanzado. Para nada.

Puedes trabajar en tu máquina local, correr el inspector de MCP, y probar lo que estás construyendo en TypeScript por ejemplo o alguno de los lenguajes compatibles (te los dejo al final del artículo). También puedes configurar un MCP existente mediante un archivo JSON, así bien simple.

Además, puedes testear las herramientas que desarrollas directamente integradas en Claude, gratuitamente.

Mi experiencia práctica

Así fue como pude crear mi primer servidor MCP en TypeScript, siguiendo el tutorial de Midu. Usé un Inspector MCP local para probar herramientas (npx -y @modelcontextprotocol/inspector npx -y tsx main.ts se ejecuta en el puerto 6274), activé la vista de desarrollador en Claude para testear lo que estaba construyendo, automaticé pull requests en GitHub con @modelcontextprotocol/server-github y logré crear un agente conectado con la API del clima, para que me respondiera en tiempo real qué clima había en la ciudad que le estaba consultando y también logré acceder al sistema de archivos local para leer y guardar archivos de forma controlada.

Lo más emocionante: tan solo con la capacidad de leer y guardar archivos, podríamos darle contexto al modelo con información ubicada en el directorio X, y guardar los resultados sintetizados de nuestras consultas en el directorio Y.

Todo bajo control. Sin alucinaciones. Con pasos claros. ¡Todo desde tu local!

Así se vería la configuración MCP que está disponible para acceder a tu file system, en este caso le estamos dando acceso al Escritorio. Al agregar esta herramienta en Claude podemos interactuar con el agente, pedir que lea los archivos en escritorio, que nos de outputs en base a eso y que los almacene en archivos.

Bueno, ¿y por qué deberías estar explorándolo tú también?

No solo porque es algo que llegó para quedarse, ni para subirse al hype. Esto va más allá.

Deberías empezar a explorarlo porque:

Si sientes que vas tarde: hoy es lo más temprano que puedes empezar.
No necesitas experiencia en IA.
Tampoco necesitas aprender un lenguaje nuevo: MCP tiene SDKs oficiales en TypeScript, Python, Java, Kotlin y C#, así que probablemente ya puedes empezar con lo que sabes (y si no, quizás es el momento perfecto para aprender algo nuevo con un proyecto entretenido).
Puedes abrir tu ventana de la creatividad. Explorando MCPs se te van a ocurrir mil formas de conectar herramientas y descubrir nuevas posibilidades.
Además, MCP es agnóstico al modelo. Puedes usarlo con Claude, ChatGPT, Gemini o el que venga.

El modelo no importa tanto. Lo importante es el contexto que le das, las instrucciones, las herramientas que expones y los permisos que definas.

Explorar es muy sencillo

Una idea rondando tu cabeza es suficiente, no necesitas tener un gran proyecto en mente. Puedes partir envolviendo una API que ya usas, creando un flujo automatizado simple, o simplemente jugando con archivos locales.

Y si algo te incomoda en el camino (como dar permisos, entender qué ve el modelo o qué puede ejecutar), está bien. Esa incomodidad es parte del aprendizaje.

Cuestionar los límites es parte del proceso. Así construimos IA más responsable.

Links a explorar 100% recomendado:

Te dejo algunos links útiles por si quieres comenzar (como lo hice yo 👀):

MCP no resuelve todo por ti, pero te da el poder de decidir cómo y con qué construir.

¿Ya lo probaste? Si aún no lo haces, ojalá este blogcito te inspire a dar el primer paso. Puedes comenzar leyendo archivos de tu sistema local, automatizando un pull request en GitHub, conectando una API como la del clima o incluso creando una herramienta que te ayude a organizar tus notas.
Lo importante no es el tamaño del proyecto, sino las ganas de explorar ✨