You know what's common in startups, developers, and even tech giants?
FOMO. Fear of missing out on the next big thing.

And right now, that "big thing" is AI agents.

Ever since Anthropic released MCP, the landscape started shifting. Now even Google is deep-diving into agentic workflows. Why?

Because no one wants to be late to the Agent Party. 🎉

Let’s break it down with a fun analogy. 🍕

Meet the Characters

Imagine you're using Zomato and you say:

"Hey, I want to have some pizza."

Zomato is smart now — it’s powered by an AI agent.
But here's the thing:

👉 Zomato cannot directly talk to PizzaHut’s database.
👉 Nor can it contact McDee’s secret sauce (MongoDB).

So, what does it do?

Enter MCP & A2A: The Real MVPs

• MCP (Model Context Protocol) is how agents talk to their own data — like ordering from their own kitchen.

• A2A (Agent-to-Agent) is how they talk to each other — like calling PizzaHut and McDee for collaboration.

Here’s how it looks visually:

Behind the Scenes

• PizzaHut’s agent connects to a PostgreSQL database via MCP.

• McDee’s agent uses MCP to access MongoDB.

• Zomato’s agent, powered by Kafka + Postgres, says:

  “Hey PizzaHut Agent, what pizzas do you have?”
  “Hey McDee Agent, any burgers to go with it?”

All this through A2A protocol. Smooth, secure, and scalable.

The Future is Inter-Agent

Today, everyone’s building apps.
Tomorrow, you’ll be building agents that talk to each other.

This isn’t just integration.
It’s cooperation.
And MCP + A2A is how they pull it off.

Final Thought

Zomato never directly talks to PizzaHut.
It respects boundaries.
But with A2A, they’re still besties. 🧑‍🤝‍🧑

And that’s the future of composable, intelligent systems.

Want to build your own agents?
Start with MCP.
Level up with A2A.

Because FOMO isn't just for devs. Even Zomato doesn’t wanna miss that pizza party. 🍕

🧠 I post regular content on AI Agents, MCP, and the agentic future —

Subscribe so you don’t miss the next big thing in this evolving ecosystem!

📩 Got questions or ideas?
Reach out at shayan.developer12@gmail.com — always happy to connect!

Unlike most tutorials that rely on Claude Desktop, I built my own MCP client from scratch using the official MCP SDK and Anthropic’s Claude API. This gave me full control and flexibility to customize behavior, tool invocation, and responses—exactly how real AI agents should work.

🌟 What You'll Build

You’ll build an AI agent that:

✅ Understands natural queries like

“What’s the weather in Florida?”

✅ Uses Claude as the LLM
✅ Invokes custom tools via MCP (e.g. get-alerts, get-forecast)
✅ Works locally using Node.js, TypeScript, and Open Tool Protocols
✅ Looks like a CLI but works like an agent 🤖

📁 Final Project Structure

mcp-ai-agents/
├── mcp-client-typescript/
│   ├── index.ts
│   ├── tsconfig.json
│   └── package.json
├── weather/
│   ├── src/
│   │   └── index.ts
│   ├── tsconfig.json
│   └── package.json

✅ Step 1: Setup the MCP Client (Claude Agent)

1.1 Create the Client Directory

mkdir mcp-ai-agents
cd mcp-ai-agents
mkdir mcp-client-typescript
cd mcp-client-typescript

1.2 Initialize and Install Dependencies

npm init -y
npm install @anthropic-ai/sdk @modelcontextprotocol/sdk dotenv
npm install -D typescript @types/node

1.3 Add Basic Setup Files

touch index.ts
touch .env

.env content:

ANTHROPIC_API_KEY=sk-xxx-your-anthropic-key

1.4 Configure TypeScript

tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["index.ts"],
  "exclude": ["node_modules"]
}

package.json (add "type" and "scripts")

{
  "type": "module",
  "scripts": {
    "build": "tsc && chmod 755 build/index.js"
  }
}

1.5 MCP Client Code (index.ts)

import { Anthropic } from "@anthropic-ai/sdk";
import {
  MessageParam,
  Tool,
} from "@anthropic-ai/sdk/resources/messages/messages.mjs";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import readline from "readline/promises";
import dotenv from "dotenv";

dotenv.config();

const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
if (!ANTHROPIC_API_KEY) {
  throw new Error("ANTHROPIC_API_KEY is not set");
}

class MCPClient {
  private mcp: Client;
  private anthropic: Anthropic;
  private transport: StdioClientTransport | null = null;
  private tools: Tool[] = [];

  constructor() {
    this.anthropic = new Anthropic({ apiKey: ANTHROPIC_API_KEY });
    this.mcp = new Client({ name: "mcp-client-cli", version: "1.0.0" });
  }

  async connectToServer(serverScriptPath: string) {
    const command = serverScriptPath.endsWith(".py")
      ? process.platform === "win32" ? "python" : "python3"
      : process.execPath;

    this.transport = new StdioClientTransport({ command, args: [serverScriptPath] });
    this.mcp.connect(this.transport);

    const toolsResult = await this.mcp.listTools();
    this.tools = toolsResult.tools.map((tool) => ({
      name: tool.name,
      description: tool.description,
      input_schema: tool.inputSchema,
    }));
    console.log("✅ Connected to server with tools:", this.tools.map(t => t.name));
  }

  async processQuery(query: string) {
    const messages: MessageParam[] = [{ role: "user", content: query }];
    const finalText = [];

    const response = await this.anthropic.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1000,
      messages,
      tools: this.tools,
    });

    for (const content of response.content) {
      if (content.type === "text") {
        finalText.push(content.text);
      } else if (content.type === "tool_use") {
        const result = await this.mcp.callTool({
          name: content.name,
          arguments: content.input as object,
        });

        finalText.push(`[Calling tool ${content.name} with args ${JSON.stringify(content.input)}]`);

        messages.push({ role: "user", content: result.content as string });

        const followUp = await this.anthropic.messages.create({
          model: "claude-3-5-sonnet-20241022",
          max_tokens: 1000,
          messages,
        });

        finalText.push(
          followUp.content[0].type === "text" ? followUp.content[0].text : ""
        );
      }
    }

    return finalText.join("\n");
  }

  async chatLoop() {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    console.log("\n🤖 MCP Client Started!\n(Type 'quit' to exit)");

    while (true) {
      const message = await rl.question("\nQuery: ");
      if (message.toLowerCase() === "quit") break;

      const response = await this.processQuery(message);
      console.log("\n" + response);
    }

    rl.close();
  }

  async cleanup() {
    await this.mcp.close();
  }
}

async function main() {
  const mcpClient = new MCPClient();
  const scriptPath = process.argv[2];
  if (!scriptPath) return console.error("❌ Usage: node index.js <path_to_server_script>");

  await mcpClient.connectToServer(scriptPath);
  await mcpClient.chatLoop();
  await mcpClient.cleanup();
}

main();

☁️ Step 2: Set Up the Weather Tool Server

2.1 Create and Init Server Folder

cd ..
mkdir weather
cd weather
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node
mkdir src
touch src/index.ts

2.2 tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

2.3 package.json

{
  "type": "module",
  "bin": {
    "weather": "./build/index.js"
  },
  "scripts": {
    "build": "tsc && chmod 755 build/index.js"
  },
  "files": [
    "build"
  ]
}

2.4 Weather Server Code

Inside src/index.ts:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const NWS_API_BASE = "https://api.weather.gov";
const USER_AGENT = "weather-app/1.0";

const server = new McpServer({
  name: "weather",
  version: "1.0.0",
  capabilities: { tools: {}, resources: {} },
});

// Helper to fetch NWS API
async function makeNWSRequest<T>(url: string): Promise<T | null> {
  const headers = {
    "User-Agent": USER_AGENT,
    Accept: "application/geo+json",
  };
  try {
    const res = await fetch(url, { headers });
    if (!res.ok) throw new Error("Fetch error " + res.status);
    return await res.json();
  } catch (err) {
    console.error("NWS fetch error:", err);
    return null;
  }
}

// --- Weather Tool: Get Alerts ---
server.tool("get-alerts", "Get weather alerts for a state", {
  state: z.string().length(2),
}, async ({ state }) => {
  const data = await makeNWSRequest(`${NWS_API_BASE}/alerts?area=${state}`);
  if (!data || !data.features?.length) {
    return { content: [{ type: "text", text: "No alerts found." }] };
  }

  const formatted = data.features.map((f: any) =>
    `Event: ${f.properties.event}\nArea: ${f.properties.areaDesc}\n---`
  ).join("\n");

  return {
    content: [{ type: "text", text: formatted }],
  };
});

// --- Weather Tool: Get Forecast ---
server.tool("get-forecast", "Get weather forecast for a location", {
  latitude: z.number(),
  longitude: z.number(),
}, async ({ latitude, longitude }) => {
  const points = await makeNWSRequest(`${NWS_API_BASE}/points/${latitude},${longitude}`);
  const forecastUrl = points?.properties?.forecast;
  if (!forecastUrl) return { content: [{ type: "text", text: "No forecast available." }] };

  const forecastData = await makeNWSRequest(forecastUrl);
  const periods = forecastData?.properties?.periods || [];

  const forecastText = periods.map((p: any) =>
    `${p.name}: ${p.temperature}°${p.temperatureUnit}, ${p.shortForecast}`
  ).join("\n");

  return {
    content: [{ type: "text", text: forecastText }],
  };
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("🌤️ Weather MCP Server running...");
}
main();

🚀 Step 3: Run Your Agent

3.1 Build both client and server

# From project root
cd weather
npm run build
cd ../mcp-client-typescript
npm run build

3.2 Start the Client + Server

Inside the client directory run:

node build/index.js ../weather/build/index.js

You’ll see:

✅ Connected to server with tools: [ 'get-alerts', 'get-forecast' ]
🤖 MCP Client Started!

Now type your query:

Query: what’s the weather in Florida?

🧠 How It Works

🧩 The Client = Claude + MCP SDK
🛠️ The Server = Tool logic exposed via MCP SDK
🗣️ Claude = uses tools when needed (tool_use)
🔁 Client = reads tool_use, sends to server, replies back to Claude
🎯 Final response = intelligent + tool-aware

🖼️ Visual Summary

You ➝ Claude ➝ tool_use ➝ MCP Client ➝ Tool Server ➝ result ➝ Claude ➝ Final Answer

💬 Example Output

Query: what's the weather in Florida?
[Calling tool get-alerts with args {"state":"FL"}]
... returns active alerts like:

- Rip Currents
- Red Flag Warnings
- Fire Weather Conditions

🏁 That's a Wrap!

You’ve now built your first Claude + MCP-powered AI Agent with:

✅ Tool use
✅ Local dev
✅ Type-safe schemas with Zod
✅ Full loop integration

👋 Got Questions or Ideas? If you have any queries or concerns regarding the AI Agent domain, just drop me an email at shayan.developer12@gmail.com.

🔔 Subscribe for more updates, walkthroughs, and deep dives as we build the future of agents together.

If you've heard buzzwords like "LLM tool-use", "AI agents", or "context injection", MCP is the protocol quietly making it all work.

📦 What is MCP?

Model Context Protocol (MCP) is a standard that allows language models (LLMs) to:

• Call external tools

• Access dynamic context

• Retrieve real-world data

• Take actions based on reasoning

It creates a clean separation between:

• 🧠 Thinking (done by the LLM)

• 🛠 Doing (handled by tools, APIs, servers)

Think of it as a developer-friendly API layer for the brain of an AI.

🧩 Core Components of MCP

🧠 How MCP Works – The Flow

Here’s what happens under the hood when an AI agent interacts with tools:

1. You ask the model to do something (e.g., "summarize these files")

2. LLM thinks: “I need to read some files”

3. It decides to call a tool like read_file

4. MCP Client sends that tool call to the right MCP Server

5. MCP Server fetches the data and returns it

6. LLM continues reasoning and gives you the final result

It's not just text generation anymore — it's intelligent action.

⚖️ Tools vs Resources

• Tools are functions that do something:
  → Fetch weather, run a query, send a message

• Resources are context providers:
  → Load file contents, get a config, fetch a user profile

LLMs decide when to use each — just like a human dev would decide what script or API to call.

💡 Why MCP Matters

• 🧠 Smarter models: They don’t just guess, they access actual context

• 🤖 True AI agents: LLMs that can act like developers or assistants

• 🔌 Plug-and-play extensibility: Add your own APIs, data, tools

• 🔒 Separation of concerns: Models reason, tools do the work

🧭 Where Does This Run? (MCP Host)

The MCP Host is the environment where everything happens:

• It contains the LLM (like Claude)

• It runs the MCP Client

• It’s usually your IDE, Replit, or local machine

The host lets your agent access tools securely and locally, instead of sending data to the cloud.

Summary

🌐 The Bigger Picture

MCP isn’t just a dev protocol — it’s the foundation for real AI agents that:

• Use tools

• Think in loops

• Automate workflows

• Work locally and securely

If you're building with LLMs, the future is not prompt-chaining — it’s protocol-driven tool use, and MCP is leading the way.