📌 What is MCP (Model Context Protocol)?

MCP (Model Context Protocol) is a standard that allows AI models to interact with external tools and services in a structured way.

It was introduced by Anthropic to make AI assistants more powerful and modular.

Instead of hardcoding logic in your backend, MCP allows you to expose tools that the AI can discover and use dynamically.

Traditional AI vs MCP-Based AI

Traditional AI Integration

In traditional applications, developers manually route user requests to APIs.

Example:

if (question.includes("weather")) {
   getWeather()
}
else if (question.includes("bitcoin")) {
   getCryptoPrice()
}
else if (question.includes("joke")) {
   getJoke()
}

Problems with this approach

❌ Hardcoded logic

 ❌ Difficult to scale

 ❌ AI cannot decide which tool to use

 ❌ Adding new tools requires modifying backend code

MCP-Based AI Architecture

With MCP, tools are exposed to the AI model.

The AI decides when to use them.

Architecture:

User
 ↓
AI Model
 ↓
MCP Client
 ↓
MCP Server
 ↓
Tools (APIs, services)

This approach allows us to build dynamic AI agents.

Many modern AI tools follow this architecture including:

• Cursor IDE
• Claude Desktop

🧠 Our AI Agent Architecture

Our project contains two main components:

project
 ├ client.js
 ├ server.js
 ├ package.json
 └ .env

server.js

Defines the tools.

client.js

Acts as the AI agent that discovers and calls tools.

🛠 Tools We Will Build

Our MCP server exposes four tools.

1️⃣ Crypto Price Tool

Fetches cryptocurrency prices using CoinGecko API.

Example output:

💰 BITCOIN
Price: $68124
24h Change: 1.72%

2️⃣ Weather Tool

Fetches weather using Open-Meteo API.

Advantages:

• Free
• No API key required
• Fast

Example output:

🌤 Weather in London

Temperature: 18°C
Wind Speed: 10 km/h

3️⃣ Random Joke Tool

Uses the Official Joke API to fetch random programming jokes.

Example output:

😂 Joke

Why do programmers prefer dark mode?

Because light attracts bugs.

4️⃣ UUID Generator Tool

Generates unique identifiers using the uuid library.

Example:

🆔 UUID
9c37c0aa-1b4e-4c7e-a437-29b8cfa7b7d4

UUIDs are commonly used for:

• database IDs
• session tokens
• unique transaction references

⚙️ Step 1 — Install Dependencies

First install the required packages:

npm install @modelcontextprotocol/sdk openai axios uuid zod dotenv

These packages allow us to:

• Create MCP servers
• Connect AI models
• Fetch API data
• Validate inputs

🧩 Step 2 — Create the MCP Server

The MCP server defines and exposes tools.

Each tool includes:

• name
• description
• input schema
• execution function

Example structure:

server.registerTool(
   tool_name,
   configuration,
   execution_function
)

Once registered, the tool becomes available to the AI.

🤖 Step 3 — Build the AI Agent

The AI agent connects to the MCP server.

Client → MCP Server

We use:

StdioClientTransport

This allows communication between client and server using standard input/output streams.

🔍 Step 4 — Automatic Tool Discovery

The AI agent dynamically fetches available tools:

client.listTools()

Output example:

get_crypto_price
get_weather
get_joke
generate_uuid

This means if we add more tools later, the agent will automatically discover them.

🧠 Step 5 — Send Tools to the AI Model

We convert MCP tools into the format required by the AI model.

The AI model we use is GPT‑4o mini.

We send the tool definitions to the model so it understands:

what tools exist
what parameters they require
when they should be used

⚡ Step 6 — AI Chooses the Tool

When a user asks:

weather in London

The AI returns a tool call.

Example:

get_weather
{
  city: "London"
}

The client then executes that tool through the MCP server.

🔄 Full System Flow

Here is the complete flow:

User Question
 ↓
AI Model
 ↓
Tool Selection
 ↓
MCP Client
 ↓
MCP Server
 ↓
API Tool Execution
 ↓
Response Returned

This design allows AI systems to scale easily.

🧪 Example Queries

You can ask the AI agent:

bitcoin price
weather in tokyo
tell me a joke
generate uuid

The AI automatically selects the correct tool.

🚀 Why MCP Is Powerful

Using MCP provides several advantages:

Dynamic Tool Discovery

No hardcoding required.

AI-Driven Decisions

The model decides which tool to call.

Scalable Architecture

You can easily add new tools like:

• database search
• file system access
• GitHub integrations
• web search

Without modifying the AI logic.

🧠 Final Thoughts

MCP is changing the way we build AI systems.

Instead of building rigid chatbot pipelines, developers can now build flexible AI agents capable of interacting with real-world tools.

This architecture is becoming the foundation of next-generation AI assistants.