Original video in Chinese.
Key Takeaway
- MCP (Model Control Protocol) is a super add-on for models and can significantly improve AI productivity, for example by combining Claude and MCP to create a low-cost version of Deep Research.
- Sequential Thinking MCP helps models carry out multi-step reasoning while maintaining logic and coherence; Tavily MCP provides optimized search engine functionality.
- MCP.so is the preferred platform for finding and hosting MCP servers, and its core competitiveness lies in MCP Server Hosting.
- I recommend paying attention to three types of MCP servers: search-related ones (such as Perplexity and Tavily), data-related ones (such as Filesystem and GitHub), and tool-related ones (integrations with specific applications).
- MCP communication depends on where the server is deployed: local runs use stdio (standard input/output streams), while cloud runs use SSE (HTTP-based remote communication).
- Even if an MCP server runs locally, it can still access the internet by calling remote APIs.
- I recommend beginners get hands-on with Tavily (SSE) and Filesystem (stdio) to understand and master MCP.
Full Content
MCP is a super add-on for models. Once you install it, you’ll find that AI productivity can actually be this high.
For example, I paired Claude-3.7 Sonnet with two MCPs, and it became a low-cost version of Deep Research.
One MCP is Sequential Thinking. It is a standardized thinking pattern that helps the model maintain logic and coherence when handling multi-step reasoning tasks. For example, it can break a complex task into clear steps. When new information appears, it can also flexibly adjust its thinking path.
The other MCP is Tavily. I introduced this before; it’s basically a search engine optimized for models.
With these two, you can see that Claude searches and thinks at the same time; based on what it finds, it adjusts its reasoning path, then does another round of searching; when it feels the information is enough and the logic is complete, it produces the final report.
After going through this whole process, I spent $1 and got a higher-quality answer. This shows two things:
First, OpenAI’s Deep Research is indeed expensive for a reason. Just from the thinking and information-gathering process you can tell it burns through a lot of tokens. OpenAI’s version is definitely even more complex.
Second, MCP is really useful. I can show you the difference. I removed Sequential Thinking and kept only internet-connected search. With the same question, the model’s answer is much simpler.
This is why I’ve been promoting MCP recently. So, where do we find MCP? And once we find it, how do we use it? In this video, I’ll give everyone a detailed answer.
Hello everyone, welcome to my channel. Modestly speaking, I’m one of the few creators in China who can clearly explain the why and how of AI. What I provide is more valuable than tutorials. Remember to hit follow. If you want to connect with me, come to the newtype community. More than 1,000 people have already joined as paying members!
Back to today’s topic: Practical Guide to MCP.
Let’s start with the first question: where do we find MCP?
If you want to use ready-made MCPs, then MCP directory websites are your first choice. In this field, the current number one is MCP.so.
MCP.so is a project by the well-known domestic developer idoubi. He has built many projects before, such as the AI search engine ThinkAny. In my last video, when I said that someone had already started building MCP infrastructure, I was talking about him.
MCP.so has already indexed more than 3,000 servers. In fact, its core competitiveness is not the directory—anyone can build a directory, and it doesn’t involve much technical difficulty. Its core competitiveness is MCP Server Hosting.
As users, with so many servers, how should we choose? I recommend paying attention to these three types of servers:
First, search-related ones. For example, Perplexity and Tavily are search. Fetch and Firecrawl are crawlers.
Second, data-related ones. For example, Filesystem lets the model access local files, and GitHub lets the model connect to code repositories.
Third, tool-related ones. For example, Blender, Figma, Slack—just from the names, you can tell which applications they integrate with.
OK, now everyone knows where to find MCP and how to choose it. So how do we connect and use it?
This is actually easy to understand. Think about it: since it’s called a “server,” where that server is deployed determines the communication method.
If it’s local, running on your own machine, you use stdio; if it’s running in the cloud, like on MCP.so, you use SSE.
stdio is standard input/output streams, usually used for local communication. For example, MCP clients like Cursor, Claude, and ChatWise communicate with MCP servers running on the same machine through standard input (stdin) and standard output (stdout).
SSE is a remote communication method based on HTTP. The MCP server is hosted remotely. Your local client communicates across machines through SSE.
It doesn’t matter if this is a little hard to follow. Let me show you what it looks like in practice.
Using ChatWise as an example: on the Tools page in Settings, click the plus button in the lower-left corner to add an MCP server. Under “Type,” we can choose between the two communication methods, stdio and SSE.
For example, for Sequential Thinking, I use stdio. The string in the command is actually the parameters required by GitHub. Because it doesn’t need an API key or anything like that, the environment variables below are left blank.
For some MCPs that require environment variables, like Tavily, just fill in the API key. Click “View Tools,” and ChatWise will try to connect, then list all the tools under that MCP.
So what does SSE look like?
For example, for Firecrawl, I use SSE. This is much simpler—you just need to fill in the link. So where does the link come from?
Remember what I just said? If the MCP server is running in the cloud, you connect to it via SSE. MCP.so provides exactly this kind of cloud service.
Go to the Firecrawl page on that website, enter your API key on the right, click “Connect,” and it will generate a dedicated link. Copy that link and paste it into ChatWise, and you’re done.
So you can understand it in a simple, straightforward way like this:
If the MCP server is running on your own machine, then you have to fill in the parameters and environment variables yourself. Just make a few small adjustments according to what GitHub asks for.
If the MCP server is running on a cloud server like MCP.so, then you provide the API key, it gives you a link, and the configuration is finished.
There’s one point I need to emphasize again: an MCP server running locally does not mean it can’t access the internet.
For example, with Tavily, I chose to run it locally. My MCP client—namely ChatWise—communicates locally with the Tavily MCP server via stdio. Then the Tavily MCP server uses HTTP requests to call the remote Tavily API and complete the search.
So let me summarize:
To find MCP servers, go to MCP.so. Then choose whether or not you want to run it locally. If you do, click the button on the right to go to the project’s GitHub page and see what parameters and environment variables need to be filled in. If not, just paste the MCP.so link into your client settings.
After watching the video, I recommend everyone try it themselves. Just pick these two projects: Tavily and Filesystem. Use SSE for Tavily and stdio for Filesystem. Once you get these two running, you’ll know how MCP works. Your AI productivity will definitely improve significantly.
OK, that’s all for this episode. If you want to talk about AI, come join our newtype community. See you next time!