Construct and Deploy a Customized MCP Server from Scratch

What’s MCP and How Does it Work?

You may consider MCP just like the USB-C port on a laptop computer. One port offers you entry to a number of capabilities resembling charging, information switch, show output, and extra, with no need separate connectors for every objective.

In an identical manner, the Mannequin Context Protocol gives a normal, safe, real-time communication interface that enables AI methods to attach with exterior instruments, API providers, and information sources.

Not like conventional API integrations, which require separate code, authentication flows, documentation, and ongoing upkeep for every connection, MCP gives a single unified interface. You write the combination as soon as, and any AI mannequin that helps MCP can use it immediately. This makes device growth extra constant and scalable throughout completely different environments.

Why It Issues

Earlier than MCP:

• Each AI app (M) wanted {custom} code to attach with each device (N), leading to M × N distinctive integrations.

• There was no shared protocol throughout instruments and fashions, so builders needed to reinvent the wheel for every new connection.

After MCP:

• You may outline or expose a number of instruments inside a single MCP server.

• Any AI app that helps MCP can use these instruments immediately.

• Integration complexity drops to M + N, since instruments and fashions converse a shared protocol.

Structure

MCP follows a client-server structure:

• Consumer: An AI utility (resembling an LLM agent, RAG pipeline, or chatbot) that should carry out exterior duties.

• Server: Hosts callable instruments resembling “question CRM,” “fetch Slack messages,” or “run SQL.” These instruments are invoked by the consumer and return structured responses.

The consumer sends structured requests to the MCP server. The server performs the requested operation and returns a response that the mannequin can perceive.

On this tutorial, you will notice how one can construct a {custom} MCP server utilizing FastMCP, take a look at it regionally, after which add and deploy it within the Clarifai platform.

FastMCP is a high-level Python framework that takes care of the low-level protocol particulars. It permits you to concentrate on defining helpful instruments and exposing them as callable actions, with out having to put in writing boilerplate code for dealing with the protocol.

Why Construct a Customized MCP Server?

There are already many ready-to-use MCP servers out there. For instance, you will discover MCP servers constructed particularly to attach with instruments like GitHub, Slack, Notion, and even general-purpose REST APIs. These servers expose predefined instruments that work effectively for frequent use instances.

Nonetheless, not each workflow may be coated by present servers. In lots of real-world eventualities, you’ll need to construct a {custom} MCP server tailor-made to your particular surroundings or utility logic.

It is best to take into account constructing a {custom} server when:

• You’ll want to join with inner or unsupported instruments: In case your group depends on proprietary methods, inner APIs, or {custom} workflows that are not publicly uncovered, you’ll want a {custom} MCP server to interface with them. Whereas MCP servers exist for a lot of frequent instruments, there received’t be one out there for each system you need to combine. A {custom} server means that you can securely wrap inner endpoints and expose them by a standardized, AI-accessible interface.

• You want full management over device habits and construction: Off-the-shelf MCP servers prioritize flexibility, however when you require {custom} logic, validation, response shaping, or tightly outlined schemas tailor-made to your corporation guidelines, constructing your individual instruments offers you clear, maintainable management over each performance and construction.

• You need to handle efficiency or deal with massive workloads: Operating your individual MCP server permits you to select the deployment surroundings and allocate particular GPU, CPU, and reminiscence assets to match your efficiency and scaling wants.

Now that you’ve got seen why constructing a {custom} MCP server may be needed, let’s stroll by the right way to construct one from scratch.

Construct a Customized MCP Server with FastMCP

On this part, let’s construct a {custom} MCP server utilizing the FastMCP framework. This MCP server comes with three instruments designed for blog-writing duties:

• Run a real-time search to search out prime blogs on a given subject

• Extract content material from URLs

• Carry out key phrase analysis with autocomplete and developments information

Let’s first construct this regionally, take a look at it, after which deploy it to the Clarifai platform the place it might probably run securely, scale routinely, and serve any MCP-compatible AI agent.

What Instruments Will This MCP Server Expose?

This server gives three instruments (capabilities the LLM can invoke):

1. multi_engine_search
   Queries a search engine (like Google) utilizing SERP API and returns the highest 5 article URLs.

2. extract_web_content_from_links
   Makes use of newspaper3k to extract readable content material from a listing of URLs.

3. keyword_research
   Performs light-weight Search engine marketing evaluation utilizing SERP API’s autocomplete and developments options.

Step 1: Set up Dependencies

Set up the required Python packages

Additionally, set your Clarifai Private Entry Token (PAT) as an surroundings variable:

Step 2: Challenge Construction

To create a legitimate Clarifai MCP server challenge, your listing ought to observe this construction:

your_model_directory/
├── 1/
│   └── mannequin.py
├── necessities.txt
├── config.yaml

Let’s break that down:

• 1/mannequin.py: Your core MCP logic goes right here. You outline and register your instruments utilizing FastMCP.

• necessities.txt: Lists Python packages wanted by the server throughout deployment.

• config.yaml: Comprises metadata and configuration settings wanted for importing the mannequin to Clarifai.

It’s also possible to generate this template utilizing the Clarifai CLI:

Step 3: Implement mannequin.py

Right here is the whole MCP server logic:

Understanding the Elements

Let’s break down every part of the above mannequin.py file

a. Initialize the FastMCP Server

The server is initialized utilizing the FastMCP class. This occasion acts because the central hub that registers all instruments and serves requests. The title you assign to the server helps distinguish it throughout debugging or deployment.

Optionally, you can even cross parameters like directions, which describe what the server does, or stateless_http, which permits the server to function over stateless HTTP for less complicated, light-weight deployments.

b. Outline Instruments Utilizing Decorators

The facility of an MCP server comes from the instruments it exposes. Every device is outlined as an everyday Python operate and registered utilizing the @server.device(...) decorator. This decorator marks the operate as callable by LLMs by the MCP interface.

Every device contains:

• A novel title (used because the device ID)

• A brief description that helps fashions perceive when to invoke the device

• Clearly typed and described enter parameters utilizing Python sort annotations and pydantic.Subject

This instance contains three instruments:

1. multi_engine_search: Makes use of SerpAPI to seek for articles or blogs. It accepts a question and choices like search engine, location, and machine sort. Returns a listing of prime URLs.

2. extract_web_content_from_links: Takes a listing of URLs and makes use of the newspaper3k library to extract important content material from every web page. Returns the extracted textual content (truncated for brevity).

3. keyword_research: Combines autocomplete and developments APIs to recommend related key phrases and rank them by reputation. Helpful for Search engine marketing-focused content material planning.

These instruments can work independently or be chained collectively to create agent workflows like discovering article sources, extracting content material, and figuring out Search engine marketing key phrases.

c. Outline Clarifai’s Mannequin Class

The custom-named mannequin class serves as the combination level between your MCP server and the Clarifai platform.

You will need to outline it by subclassing Clarifai’s MCPModelClass and implementing the get_server() technique. This technique returns the FastMCP server occasion (resembling server) that Clarifai ought to use when operating your mannequin.

When Clarifai runs the mannequin, it calls get_server() to load your MCP server and expose its outlined instruments and capabilities to LLMs or different brokers.

Step 4: Outline config.yaml and necessities.txt

To deploy your {custom} MCP server on the Clarifai platform, you want two key configuration recordsdata: config.yaml and necessities.txt. Collectively, they outline how your server is constructed, what dependencies it wants, and the way it runs on Clarifai’s infrastructure.

The config.yaml file is used to configure the construct and deployment settings for a {custom} mannequin (or, on this case, a MCP server) on the Clarifai platform. It tells Clarifai the right way to construct your mannequin’s surroundings and the place to position it inside your account.

Understanding the config.yaml File

build_info

This part specifies the Python model that Clarifai ought to use to construct the surroundings to your MCP server. It ensures compatibility along with your dependencies. Clarifai presently helps Python 3.11 and three.12 (with 3.12 being the default). Choosing the proper model helps keep away from points with libraries like pydantic v2, fastmcp, or newspaper3k.

inference_compute_info

This defines the compute assets allotted when your MCP server is operating inference — in different phrases, when it’s stay and responding to agent requests.

• cpu_limit: 1 means the mannequin will get one CPU core for its execution.

• cpu_memory: 1Gi allocates 1 gigabyte of RAM.

• num_accelerators: 0 specifies that no GPUs or different accelerators are wanted.

This setup is often sufficient for light-weight servers that simply make API calls, run information parsing, or name Python instruments. When you’re deploying heavier fashions (like LLMs or imaginative and prescient fashions), you possibly can configure GPU-backed or high-performance compute utilizing Clarifai’s Compute Orchestration.

mannequin

This part registers your MCP server inside the Clarifai platform.

• app_id teams your server underneath a particular Clarifai app. Apps act like logical containers for fashions, datasets, and workflows.

• id is your mannequin’s distinctive identifier. That is how Clarifai refers to your MCP server within the UI and API.

• model_type_id should be set to mcp, which tells the platform it is a Mannequin Context Protocol server.

• user_id is your Clarifai username, used to affiliate the mannequin along with your account.

Each MCP mannequin should stay inside an app. An app acts as a self-contained challenge for storing and managing information, annotations, fashions, ideas, datasets, workflows, searches, modules, and extra.

necessities.txt: Outline Dependencies

The necessities.txt file lists all of the Python packages your MCP server depends upon. Clarifai makes use of this file throughout deployment to routinely set up the required libraries, guaranteeing your server runs reliably within the specified surroundings.

Right here’s the necessities.txt for the {custom} MCP server we’re constructing:

This setup contains:

• clarifai, mcp, and fastmcp for MCP compatibility and deployment

• anyio and requests for networking and async help

• lxml and newspaper3k for content material extraction and HTML parsing

• google-search-results for integrating SERP APIs

Step 5: Check the MCP Server Regionally

Earlier than deploying to manufacturing, at all times take a look at your MCP server regionally to make sure your instruments work as anticipated.

Possibility 1: Use Native Runners

Consider native runners like “ngrok for AI fashions.” They allow you to simulate your deployment surroundings, route actual API calls to your machine, and debug in actual time — all with out pushing to the cloud.

To begin:

clarifai mannequin local-runner

This can:

• Spin up your MCP server regionally

• Simulate real-world requests to your instruments

• Allow you to validate outputs and catch errors early

Try the Native Runner information to learn to configure the surroundings and run your fashions regionally.

Possibility 2: Run Automated Unit Assessments with test-locally

For a quicker suggestions loop throughout growth, you possibly can write take a look at instances immediately in your mannequin.py by implementing a take a look at() technique in your mannequin class. This allows you to validate logic with out spinning up a stay server.

Run it utilizing:

clarifai mannequin test-locally --mode container

This command:

• Launches a neighborhood container

• Routinely calls the take a look at() technique you’ve outlined

• Runs assertions and logs leads to your terminal

You will discover the complete test-locally information right here to correctly arrange your surroundings and run native exams.

Add and Deploy MCP Server

After you have configured your mannequin.py, config.yaml, and necessities.txt, the ultimate step is to add and deploy your MCP server in order that it might probably serve requests from brokers in actual time.

Step 6: Add the Mannequin

From the basis listing of your challenge, run the next command:

clarifai mannequin add

This command uploads your MCP server to the platform, utilizing the configuration you laid out in your config.yaml. As soon as the add is profitable, the CLI will return the general public MCP endpoint:

https://api.clarifai.com/v2/ext/mcp/v1/customers/YOUR_USER_ID/apps/YOUR_APP_ID/fashions/YOUR_MODEL_ID

This URL is the inference endpoint that brokers will name when invoking instruments out of your server. It is what connects your code to real-world use.

Step 7: Deploy on Compute

Importing your server will register it to the Clarifai app you outlined within the config.yaml file. To make it accessible and able to serve requests, it’s good to deploy it to devoted compute.

Clarifai’s Compute Orchestration, permits you to create and handle your individual compute assets. It brings the flexibleness of serverless autoscaling to any surroundings — whether or not you are operating on cloud, hybrid, or on-prem {hardware}. It dynamically scales assets to fulfill workload calls for whereas providing you with full management over how and the place your fashions run.

To deploy your MCP server, you’ll first must:

1. Create a compute cluster – a logical group to arrange your infrastructure.

2. Create a node pool – a set of machines along with your chosen occasion sort.

3. Choose an occasion sort – since MCP servers are usually light-weight, a fundamental CPU occasion is enough.

4. Deploy the MCP server – as soon as your compute is prepared, you possibly can deploy your mannequin to the chosen cluster and node pool.

This course of ensures that your MCP server is at all times on, scalable, and capable of deal with real-time requests with low latency.

You may observe this information or this tutorial to learn to create your individual devoted compute surroundings and deploy your mannequin to the platform.

Work together With Your MCP Server

As soon as your MCP server is deployed, you possibly can work together with it utilizing a FastMCP consumer. This lets you listing the instruments you have registered and invoke them programmatically utilizing your server’s endpoint.

Right here’s how the consumer works:

1. Consumer Setup

You’ll use the fastmcp.Consumer class to hook up with your deployed MCP server. This handles device itemizing and invocation over HTTP.

2. Transport Layer

The consumer makes use of StreamableHttpTransport to speak with the server. This transport is well-suited for many deployments and allows easy interplay between your app and the server.

3. Authentication

All requests are authenticated utilizing your Clarifai Private Entry Token (PAT), which is handed as a bearer token within the request header.

4. Device Execution Movement

Within the instance consumer, three instruments from the MCP server are invoked:

• multi_engine_search: Takes a question and returns prime weblog/article hyperlinks utilizing SerpAPI.

• extract_web_content_from_links: Downloads and parses article content material from given URLs utilizing newspaper3k.

• keyword_research: Performs key phrase analysis utilizing autocomplete and developments information to return high-potential key phrases.

Every device is invoked through consumer.call_tool(...), and outcomes are parsed utilizing Python’s json module to show readable output.

Now that your {custom} MCP server is stay, you possibly can combine it into your AI brokers. The brokers can use these instruments to finish duties extra successfully. For instance, they will use real-time search, content material extraction, and key phrase evaluation to put in writing higher blogs or create extra related content material.

Conclusion

On this tutorial, we constructed a {custom} MCP server utilizing FastMCP and deployed it to devoted compute on Clarifai. We explored what MCP is, why constructing a {custom} server issues, the right way to outline instruments, configure the deployment, and take a look at it regionally earlier than importing.

Clarifai takes care of the deployment surroundings together with provisioning, scaling, and versioning so you possibly can focus fully on constructing instruments that LLMs and Brokers can name securely and reliably.

You need to use the identical course of to deploy your individual {custom} fashions, open supply fashions, or fashions from Hugging Face or different suppliers. Clarifai’s Compute Orchestration helps all of those. Try the docs or tutorials to get began.