Unlock Peak Productivity with Model Context Protocol - by Nikolay Stoitsev

This talk introduces the Model Context Protocol (MCP), an open standard designed to integrate various AI systems and tools seamlessly. The speaker, a senior engineering manager, explains how MCP enables AI applications to automatically discover capabilities and work with external systems without complex configurations. He discusses advancements such as structured outputs and function calling in AI, which lay the groundwork for MCP's functionality. By leveraging MCP, developers can automate tasks across platforms like JIRA and AWS, enhancing productivity and workflow management. The protocol's implementation allows for dynamic discovery of tools and streamlining of interactions, making AI systems more contextually aware and versatile.

Challenge accepted. [music] Challenge Challenge accepted. Challenge [music] accepted. Challenge accepted. P2 is always [music] challenge accepted. AI is everywhere these days but let's be honest using it in real life production feels often feels like juggling dozens of tool which doesn't really talk to each other >> that's exactly where the model context protocol MC MSP >> MCP >> MCP comes in it's a new open standard that allows

AI systems tools tools and apps to actually work together. Think of it as the missing API for your AI stack. >> Our next speaker will show us how MCP can tr through the noise, reducing integration overhead, automating boring tasks and unlocking workflows that are truly context aware. >> He is a senior engineering manager at at storepool storage leading teams that build blazing fast, highly available and super

scalable distributed systems. use it worldwide. >> He's spoken at Openfest, Easter, Hackcom, JS talks, and today he's bringing us a fresh practical look at how AI can be tamed with MCP. Please make some noise. >> He's also one of our proud nominee for a death of the year award 2025. >> Please make some noise for Nikolai. >> Silence accepted. Silence [music] is always challenge accepted. Challenge >>

Hello. Hello everyone. I'm super happy to be here. Okay. Um and first I'm going to start with the story. I'm going to talk about um one of the greatest physicists of our time, Richard Fineman. And he was very famous of doing physics. He was doing a lot of complicated physics all the time, right? Complex math, uh complex physics, inventing stuff. Um and sometimes he got stuck. Sometimes

he loved physics. It was super awesome for him to do the math, to do the physics. But sometimes there happened that it it was getting boring for him or he got stuck. He didn't know how to continue. And what he did in those cases, there is one very famous example where he got really stuck and he went to a restaurant. In the restaurant, the plate was a

little bit wobbling because the surface was not even he started to calculate um using physics how the plate is going to wobble. And this pushed him in one of the things that uh was part of the work that get got him a Nobel Prize nomination. It was just something that oh the plate is wobbling and I'm going to play with the things that I'm doing. Um not

treated as work but treated as play. And this is how he was like motivating himself. And in general when we have something to do when we treat it as play when we treat it as something that we experiment with that we play around uh we find the motivation to be more productive right but when the AI tools first initially came up this is like the first version

of chpt it didn't quite feel that way we were able to type in stuff but it was like very cumbersome you need to always copy stuff from different places and if you want to create a script that used the API of 3.5 GPT 3.5 for example it was very hard to work with it so you want to write a script to build some product on top of

this API of this large language model and uh it was returning different responses even if you say I want a JSON response sometimes it returns JSON responses something and sometimes it says here is a JSON response that that to that and that it makes it invalid, right? And you cannot parse it every time. It was very tedious, right? And the first step of um that I saw

like these tools becoming more available for productivity improvements was something that was called structured outputs. Um this was a way that you can instruct the LM to say okay this is the output that I want to receive from the the response that you're returning. It was first introduced over API and it was a JSON schema definition of the response that you're expecting. um and the alarm was

uh following it when you provide a structure output JSON schema the model was always responding and then there was a another revolution I can say step two in making these things actually useful and this is function calling it was also introduced u first over the API um function calling or two calling different vendors call it a different way but it's the same thing you basically defined tools,

you give them to the large language model and it starts using them. It can think about in what context should I use these tool now what tools I can use. It's part of the uh training of the model to instruct it to search for tools, know what to do with the tools, know what tools are in general. Um and um it's yeah the something that gives capability

for the large language models to actually do stuff and this is one example. It's like um function definition for getting a horoscope and you can say this is this Ges horoscope for an astrological sign. Um very yeah strange tool. Um and it requires a sign and it returns a string. Um basically you say this is the function that you can call and you provide it a description

so the LM know what it is and when to use it. Um then you provide like an input and when you say when you also say to the CH GP5 for example here is the list of tools that you can use. behave if one tools in the list but it knows okay I can get a horoscope and then okay but how does it work how does it

actually what do we mean by two um and then we say well when the we need to orchestrate the tool calling we tell the model these are the tools that you can use and sometimes it can reply I want to use this tool as a response and we can say okay what is the type we get is a function is it get horoscope because this is the

tool that we're giving it. Yeah. Then we execute the logic. We call the function in our code that's called get horoscope. Um and yeah it's it yeah basically gets it and then returns it to the to the LM again. It says okay here is like your um the result of you calling this function. And then we get the final response. We are calling the LM again. And

we're saying okay this is what you what the user requested. This is the tool that you wanted. This is the result from the result from running the tool and now give me the final output. It prints the final output. Basically every time when you do tools calling you say to the LM here are the tools that you can use. And when it wants to use a tool

it says to the orchestrating code call this tool. Use this tool. And this is like this was like a giving the LMS's ability to do stuff to actually do something useful. And the model context protocol is like building on those two concepts and is like the third step of the evolution of making KLMs and AI in general more more useful. Um the structured outputs provided the ability

for the LMS to like you can think of it fill in forms. You define the form and you note what knows what fields are in the form and it can fill the form. With function calling, it can press the right button. It can know which form to fill in and to press the right button in order to do the thing that it can do. But with MCP,

it can automatically discover all the forms and all the buttons from different tools. It knows how to discover them and then it knows how to use them. You don't need custom wiring no matter what different forms in the web [snorts] equivalent the different tools if it's Jira if it's uh um graphana Figma doesn't matter they all they return different forms and the MCP protocol defines a way

for the AI to know how to work with all those forms and click the right buttons. Um so yeah the core principle behind the model context protocol that is it provides dynamic discovery and uh it interacts with external systems can discover capabilities and actually knows how to use those capabilities. Um and it's something that was started by entropic. Uh they started it as a standard. It was

like first people to put it in their products and then gradually it was adopted by different vendors. First was the AI calling assistants like cursor um like the wind service and the others. Then it was slowly adopted by Microsoft by Amazon. Then uh with with Google and then OpenAI was like the last big player but they also adopted MCP and they have MCP in their products built

in and somehow it became the de facto standard when you want to interface your LM with an external system in whichever product you're using there most probably is an MCP implementation and um so do a short overview of how MCP works. So you have some AI enabled software that you're using for example cursor. How many of you are using cursor? Show of hands. Okay, couple of people.

So cursor is um integrated developer environment with AI built in. Um you can say that it has a genty capabilities like every other shiny um coding tool out there but it's a AI coding to a coding environment. So in every such application you have an MCP client that is connecting with uh different MCP servers and you have uh for example over here we have MySQL MCP server

that connects to a MySQL database and then we have JMCP server and AWS MCP server and MCP clients ask each of those servers hey um MySQL MCP server what tools do you have and it says like um I can run queries, I can get you a scheme of the table, I can get you a scheme of the database, I can create a user, I can grant permissions.

Um, and it says what it can do. And then it says, hey, JMCP server, what um tools do you have? And the JMCP server says, well, you can uh create a project, list projects, create issue, list issues, query issues at a table, at a label, assign people, create users, uh change permissions of users. basically all the things that you can do in Jira and then the same

with AWS for example you can create a EC2 instance you can set up an S3 bucket list S3 bucket gets content of S3 bucket yeah all those things and MCP clients uh speak speed speak this protocol and give this as a context to cursor so it knows what to do and basically each of those is connected to their corresponding system um you can have locally running MySQL

on your machine or the my can be in some environment cloud environment you can connect to Jira to your Jira that's hosted in your data center in your virtual environment or you can connect to Jurro cloud and with AWS you connect to to the so it can connect to the servers are something that connects to um resources running locally and running remotely and same for servers you

can have servers running on your machine you You can also connect to servers that are hosted and use them as a software as a service. Basically, um the company behind it is running it and you just interface with it. And um there are like different servers that you can do. There are different cataloges. Here is one catalog. Every week there's like a new hot catalog for MCP

servers. Um that but basically they all do the same job. All the MCP servers are put on GitHub and they um index GitHub and give you some for some fancier UI so you can search for those those servers and there are like a lot of servers out there. this is the typical typical setup for you for using MCP. Um but there is a problem when you have

multiple clients. If you have cursor and you have cloud desktop and then you have cloud code or jin CLI or something else each of them have a different MCP client. This is how it how it works. And this in every MCP client you need to do the same configuration to connect them to the same servers. And this is like um a lot of repetitive repetitive work. And

also the servers that you're running locally, they're usually NodeJS servers that you start up, they're running. And then your application that that is using the client connects to the NodeJS application on your machine that's running. And how do you manage the life cycle? How do you upgrade it? It's a little bit cumbersome. So there's there's like a new approach that's called an MCP gateway. You have one

gateway running on your machine and it connects to all the clients. All the clients have only one configuration. In each client you just say connect to this MCP gateway and the MCP gateway usually have the availability the ability to configure it automatically and you just say connected to cursor. It because it knows where the standard location for the MCP configuration of cursor and the file system is.

Same for cloud desktop. same for Germany CLI and you can um from the gateway configure the connection to each client and then in the MCP gateway you can also manage the connections to different MCP servers and one great example of such gateway is the docker MCP toolkit um it's you maybe all of you most of you not all of you maybe most of you are using docker

and you have your desktop client and in the desktop client there's like a new MCP2 github When you click it, first you go to clients and over here you can say connect to the different clients that you have. In this example, you can see that um I have connected it to cursor and something else. Okay. Um but you can connect it and you also go to servers

and you can install servers and it's very easy because they're docker containers. Docker manages the life cycle. You can also upgrade them very easily by using the standard Docker application. It's like the full toolkit. You get the servers and you get the connection with the clients and it's like very easy way to use MCP and um okay but what you can do with with MCP and I'm

going to give you some examples um of different servers and what can what can you do with them. The first one is around code bases and repositories. Um and this this is like um sorry [clears throat] you can use different [snorts] servers here. GitHub, GitLab, Git Kraken, Context 7 is is the one MCP servers that every MCP pro is using. Every person that is like power user

of MCP when I ask them what is like the go to like your most useful thing, they they all say context 7 because it provides the most upto-date documentation of the frameworks and libraries that you're using as context. And this um makes the agents more powerful because the ls are trained on some versions of the libraries. when a new version came up is that train on the

latest APIs um and best practices and this is what context 7 patches and this is one example you can say using the GitHub MCP server create a new branch push all state changes create a pull request add labels run checks and post when you're ready post it as a comment in the in some channel and this is like one example output that you can get it created

the branch it created the pull request added the labels add reviewers link some issues from zero linear or whatever you're using and you you see build passed unit test pass but integration test failed and you know then you post it to the PR integrations test failed this is like nice automation but you can see that this prompt was a little bit wrong long right and you don't

want to write it every time and there is something that's called slashcomands that you can use in every um coding environment. Then it's they're they're usually called slashcomands. You have it you have it in cursor. You have it in uh uh github copilot basically everywhere and it's like a slash common name and then you provided some arguments. In our example, we're going to package this long prompt

as slashpr. Then you put the branch name, then you put the PR title for the PR, and it automatically calls this long prompt. Um, and you can also com combine them. You can say slash check compiler errors and slashcomit and slash create a PR. And these all are some longer prompts that you put it in as a configuration in your AI coding environment. and um it executes

some complex problems with MCP but this is like the the way to do it. Another thing that I want to show you it's an example of using Figma because a lot of people are asking me okay Figma for this it's very uh popular for designing front end how can we use it to to work with it and there is like a community server that you can use

uh community server means that it's not developed by Figma because all the other examples I'm showing you is are servers developed by the companies that are behind the products like GitHub have GitHub MCP server. GitLab Gitlab MSP server now. But for Figma, we don't have like a Figma MP server created by Figma. But again, you can say I need you to clone this this dashboard. And there

is a very nice blog article that basically show the results. And you can see on the right side is the Figma design on the left on the left side is the Figma design. on the right side is the produce code and it uh it's getting the job done at 90% right it saves a lot of time and then you just need to go in and tweak it

to make it pixel perfect if you want if this is what you need um you can also use MCP with your continuous integration continuous delivery workflows uh you can say fetch the latest failed build for this environment summarize why it's failing what is directly the rules called suggest a patch create a pull request with it and uh let's try to to fix it and this is one

example that you can get the latest failed build is number 1784 this commit um here are the failed jobs hero white probably um failed it was an integration test progress was not available when we run try to run the test okay so let's open a pull request where we do a health check and then you run the tests. Um, this is something that probably example of interfacing

with multiple systems and MCPS in order to get it working. use it for data exploration and for database access. Um, and this is really useful because when we are writing code, when we are designing our software, we need to know what are the constraints of the real world that our software is operating with. and you're maybe designing a feature for a specific subset of users and you

want to ask yourself, okay, how many users are there? Maybe how how complex should this feature be? Am I designing a feature for 10 users a month, for 10 users a day or for like 100 users a second um doing something there, it's very different, right? And you sometimes you dig in the database to see how big the use case that you're working with is. And this

is very good good relative because you can describe with plain text what you want to fetch and it translated to SQL queries and executed against your um database and [snorts] yeah there are different MCP servers for posgress for for click house for DDB. You can see that there is no MySQL here because there is no official MySQL MCP client but there are plenty of community MCP servers

for MySQL and also data hub is also a connector to has a connector to my SQL and you and also another very cool use cases when you want to replicate some buck you need to replicate on a testing environment and you want to uh see that with data because you don't want to do it on an empty environment. So you say okay get uh sample from the

production database and load it in this um environment. And this is a result result one example result of running this um query from production. It's loading to staging. It's trying to sample the same users. It's trying to um run some anonymization logic to replace the usernames, replace phone numbers um but keeping the same referential integrity. You want to keep all the foreign keys so everything can work

and you can query the data and then it validates okay is it working? Did I get the same number of rows written in the tables that I wanted and it propose some next steps. You can also use MCP for browser automation. you can make it click on stuff, execute tests. Um, MCP doesn't improve the capability of the LMS to write better tests. It's not going to help

them be better at writing playright tests, for example. But what it going to do is give them the ability to execute them. And you can say, yeah, execute those tests on for this use case. This is oversimplified so it can fit on a slide. It's usually way longer. It's not like user journey. This user journey should be like uh more uh well defined but this is what

you what you can get as as a result. Um check out workflow for guest user. It's not working on Safari because payment iframe is not loading and um you know where to dig in. It's basically faster way to run your tests and to automate browser um things with with your browsers. It can also be a glue between workflows. You can say create release nodes for this t

that I have in my um in my git and connected with yeah connected with the description of the tasks for these pull requests and this is like here is the here are the release notes these are the features that were introduces did introduce the fixes the ches and it's published to confluence or to notion and also summary posted to this like channel it automates like the process

of writing release notes one example and one thing that you need to keep in mind that I want to u there are two things that I want to finish with first is don't have too many MCP servers they bloat the context every time when you have an MCP server the clients are loading the uh tools definition that is like usually a long list if you're using some

complicated MCP server and put is putting it inside the chats that you're using inside the context so it takes sub tokens um both it bs the context it's also more expensive because you spend more money for the tokens that are the definitions of the tools and sometimes sometimes this happen uh clause is like thinking okay let me think which tool to use is 30 things for 30

seconds and it says I tried these two and then these two and then these two sometimes it gets uh confused and uh you ain't going to need it principle is super important here if something you don't need an MCP server don't just put it there. Um, be mindful what servers are you're using and you're not you're not using something, it's better to remove it. And the last

thing that I want to finish with is that S in MCP stands for security. Um, you can download some unvetted third party server. It can steal the conversations that you're having with your LLMs. Um sometimes when the MCP server replies with metadata if there is a prompt inside the metadata it's can execute it as in instructions um authentication is not solved. So usually you download a key,

you put it in your uh server to authenticate against the things the infrastructure that you're using or system that you're using and every person that access this server gets the same permission, the same authentication that you have um and there are over permissive scopes and if you think okay how can I get started with MCP server? uh you can just get your bash history or ZSH history

file put it inside an NLM give him these instructions based on the things that I'm doing what MCP server should I consider here is my bash history or ZSH history and some constraints be be specific you don't want it to hallucinate that you're using something you tell it um don't hallucinate tell me where in the where in the history uh site actual history lines and Here are

the list of servers that you're going to pick from. Don't figure out an existing servers. And pretty much that's it. Go and try and use temp in your workflows. [applause] Thank you very much, Nikolai. Any questions from the uh hall here? There's one question and this will be the only one from the call because the next one will be from the speaker corner. Okay, can you expand

a little bit on the security side because MCP is considered a little bit not mature in terms of security by many practitioners and well recently we had another exploit forcing well sending private emails just because you gave access to your calendar. So there are many of those. So what are your recommendations to stay safe? >> Yeah. Um, I think you need to be very careful when you

use it as an integration point inside the applications that we're building. It has a very good use case for personal productivity. That's why I'm aiming the discussion in terms of here's how to use it for personal productivity and you vet the servers that you use. You vet the sources of information that you use. Um, the source of inputs is like you are the source of inputs. the

servers are running on your machine and only you have access to them and uh or some cloud that are created and by the companies behind the products that you're interfacing with. So yeah, these are my recommendation. You need to be very careful if you if you provide your users ability to talk to your MCP server, you need to be very careful with it. And there are some

recent uh patches in the standard that try to um use different versions of Oout to try to solve that. And um it's not that adopted yet, but I think it's step in the right direction. We should think about it. Think about how to use standard uh solutions in the industry and it needs to be more adopted. Right now it's Yeah, there are there's a lot of work

in this direction. So I'm sure it's going to get solved but there is a lot of work in that Thank you very much. >> Thank you. >> So Nikki and Alex will be waiting for you during the next break in the speakers corner. Let's now send him off of the stage with big round of applause.