Build Your First MCP Client from Scratch (2026): A Beginner-Friendly Tutorial

Learn how to build your first MCP Client from scratch using Node.js. This beginner-friendly tutorial covers setup, architecture, code examples, and best practices.

Developer building an MCP client that communicates with an MCP server using the Model Context Protocol.

Build Your First MCP Client from Scratch

Introduction

If you've already built an MCP server, the next step is learning how an MCP client works.

An MCP client connects to an MCP server, discovers available tools and resources, sends requests, and displays the results.

Think of it as the bridge between your AI application and the external capabilities exposed by an MCP server.

By the end of this tutorial, you'll build a working MCP client from scratch and understand how every request flows between the client and server.

Quick Answer

An MCP client is an application that connects to an MCP server using a transport such as STDIO or HTTP. It discovers available tools, resources, and prompts, sends requests, and processes the responses.

What Is an MCP Client?

Imagine using ChatGPT.

When you ask,

"What's the weather in Pune?"

ChatGPT doesn't know the weather itself.

Instead, it asks another service.

That service could be an MCP server.

The component making that request is the MCP client.

So the client is responsible for:

  • Connecting

  • Sending requests

  • Receiving responses

  • Displaying results

MCP Client Architecture

+----------------+
| AI Application |
+-------+--------+
        |
        |
        v
+----------------+
|   MCP Client   |
+-------+--------+
        |
        |
 Transport
(STDIO / HTTP)
        |
        v
+----------------+
|   MCP Server   |
+-------+--------+
        |
        |
+-------+-------+
| Tools          |
| Resources      |
| Prompts        |
+---------------+

Client vs Server

Diagram of an MCP client versus an MCP server

Prerequisites

You'll need:

  • Node.js 20+

  • npm

  • Basic JavaScript

  • An MCP server (from the previous tutorial)

Step 1: Create a Project

mkdir my-mcp-client

cd my-mcp-client

npm init -y

Step 2: Install MCP SDK

npm install @modelcontextprotocol/sdk

Project Structure

my-mcp-client/

package.json

index.js

Step 3: Import Required Modules

import { Client } from "@modelcontextprotocol/sdk/client/index.js";

This gives us the core MCP client.

Step 4: Create the Client

const client = new Client({
    name: "thetechlane-client",
    version: "1.0.0"
});

This identifies your application to the server.

Step 5: Connect to the Server

Suppose your server runs with STDIO.

await client.connect(transport);

Once connected, the client and server exchange capability information.

What Happens Internally?

Client
   |
   | Connect
   |
Server
   |
   | Sends available capabilities
   |
Client stores them

Step 6: Discover Available Tools

const tools = await client.listTools();

console.log(tools);

Output

Calculator

Weather

Search

Email

Now the client knows what the server can do.

Step 7: Call a Tool

Suppose the server exposes a calculator.

const result = await client.callTool({
    name: "calculator",
    arguments: {
        a: 5,
        b: 3
    }
});

Output

8

The client never performs the calculation itself.

It asks the server.

Request Flow

Client

↓

Call Tool

↓

Server

↓

Execute Tool

↓

Return Result

↓

Client

Reading Resources

Servers can expose files or documents.

const resource = await client.readResource({
    uri: "docs://guide"
});

Output

Welcome to MCP

Listing Resources

const resources = await client.listResources();

Output

Guide

API Docs

Examples

Using Prompts

Servers can provide reusable prompts.

const prompts = await client.listPrompts();

Output

Code Review

Bug Fix

Summarize

Execute a Prompt

const prompt = await client.getPrompt({
    name: "code-review"
});

The server returns the prompt template.

Complete Flow

User

↓

AI Application

↓

MCP Client

↓

MCP Server

↓

Tool

↓

Result

↓

Client

↓

AI

↓

User

Real Project Example

Imagine building an AI coding assistant.

The assistant needs to:

  • Read project files

  • Search documentation

  • Run Git commands

  • Execute terminal commands

Instead of implementing everything inside the AI application, the assistant connects to an MCP server.

The server exposes tools like:

readFile

writeFile

searchCode

gitStatus

gitCommit

runCommand

Whenever the user asks,

"Show me modified files."

The client sends a request to the server, which executes git status and returns the result.

This separation keeps the AI focused on reasoning while the server handles external operations.

Interview Questions

What is an MCP client?

An MCP client connects to an MCP server, discovers its capabilities, sends requests, and processes the responses.

Does an MCP client execute tools?

No. It requests tool execution from the MCP server.

Can one client connect to multiple servers?

Yes. A client can manage connections to multiple MCP servers and aggregate their capabilities.

What transports can an MCP client use?

Common transports include STDIO for local processes and HTTP or WebSocket for remote communication, depending on the implementation.

Why does the client list tools before calling them?

Listing tools allows the client to discover available capabilities dynamically instead of relying on hardcoded assumptions.

Frequently Asked Questions

Can I build an MCP client without AI?

Yes. An MCP client is simply a protocol client and can be used by any application that needs to communicate with an MCP server.

Is the MCP client responsible for business logic?

Typically, no. The client coordinates communication, while the server implements the business logic.

Can one server serve multiple clients?

Yes. Depending on the transport and implementation, multiple clients can connect to the same MCP server.

Can I use TypeScript instead of JavaScript?

Absolutely. The MCP SDK supports both JavaScript and TypeScript development.

Should I hardcode available tools?

No. Use discovery methods like listTools() so your client adapts automatically when server capabilities change.

Key Takeaways

  • An MCP client initiates communication with an MCP server.

  • It discovers available tools, resources, and prompts at runtime.

  • The client sends requests; the server performs the actual work.

  • Separating client and server responsibilities makes AI applications more modular, maintainable, and extensible.

  • Understanding the client-server interaction is essential before building more advanced MCP-powered AI applications.

Previous Lesson

← Build Your First MCP Server

What's Next?

Now that you've built both an MCP server and an MCP client, it's time to learn what makes MCP truly powerful—tools.

Tools allow AI applications to perform real-world actions, such as querying databases, calling APIs, reading files, running terminal commands, or interacting with external services. Understanding how to design and expose tools is the key to building practical MCP applications.

In the next tutorial, you'll learn how to create custom MCP tools, define input schemas, return structured responses, and expose them for AI clients to use.

Next Tutorial → MCP Tools Explained: Build and Expose Your Own Tools

Continue Learning

Continue your MCP journey with these tutorials:

Have a Question?

If something isn't clear or your MCP client isn't working as expected, leave a comment below.

We'll do our best to explain it with simple language, practical examples, and code you can actually understand.

Happy Coding! 🚀

Follow TheTechLane

Want more developer tutorials, AI engineering guides, programming tips, and the latest tech updates?

Follow TheTechLane on LinkedIn, X, Instagram, Threads, and Pinterest to stay connected and never miss a new tutorial.

Learn. Build. Share.

— TheTechLane