If you are an engineer building AI Agents today (using LangGraph, AutoGen, or CrewAI), you know the struggle. You build a brilliant agent, but it is locked in a Silo.

• It can’t see your local files.
• It can’t query your internal PostgreSQL database.
• It can’t check your Linear tickets.

The Old Way (Integration Hell)

To fix this, you write “Connectors.” You write a Python function to talk to Postgres. Then another for Slack. Then another for your file system. In Agentic language, these are called Tools.

The Problem: Every time you switch frameworks (e.g., moving from a LangGraph agent to Claude Desktop), you have to rewrite these tools from scratch. You are maintaining 10 different custom tools for 10 different platforms. It is unmaintainable spaghetti code.

The Solution: MCP (The Universal Port)

MCP acts like a USB-C port for AI applications.

• Before MCP: You build a specific “Database Tool for LangGraph.”
• After MCP: You build one “Database MCP Server.”

Now, Claude Desktop, Cursor, and your custom LangGraph agent can all plug into it instantly. Write once, connect everywhere.

The Mental Model: Architecture Deep Dive

To master MCP, you need to understand the three key players. Think of this like a High-End Restaurant.

1. The Components

1. The Host (The Customer): This is the AI application. It could be Claude Desktop, Cursor, or your custom Agent (built with LangGraph/AutoGen). It has the intent (“I need to query the database”) but lacks the access.
2. The Client (The Waiter): The connector inside the Host. It takes the agent’s intent, translates it into the correct protocol (JSON-RPC), and sends it to the kitchen.
3. The Server (The Kitchen): The external process (e.g., GitHub, Database, File System). It holds the data and executes the actual work.

2. The Layers (The “How”)

How do they actually understand each other? Through two specific layers.

A. The Data Layer (JSON-RPC)

This is the language they speak. No matter what the tool is, the messages always look the same.

• Example Request:

{ “jsonrpc”: “2.0”, “method”: “tools/call”, “params”: { … } }

• Why it matters: It’s lightweight, stateless, and universally supported.

B. The Transport Layer (The Road)

This is how the JSON message travels.

• Stdio (Local): Like passing notes in class. The Host launches the Server as a subprocess and talks via Standard Input/Output. Best for: Local files, privacy, speed.
• HTTP+SSE (Remote): Like sending a text message. Uses HTTP and Server-Sent Events. Best for: Cloud deployments, sharing tools with a team.

3. The Menu (Primitives)

An MCP Server exposes three specific capabilities to the Agent:

4. The Lifecycle

The connection isn’t random; it follows a strict 3-step dance to prevent errors.

1. Handshake (Initialization):

• Client: “Hello, I speak MCP version 2024–11.”
• Server: “Hi. I support Tools and Resources.”
• Client: “Acknowledged. Let’s begin.”

2. Operation: The Agent sends tool calls, and the Server responds with results.

3. Shutdown: When you close the app, the Client sends a signal to kill the connection, ensuring no “zombie processes” eat up your RAM.

The Quick Win: Using the Connectors Directory

You don’t need to be a coder to give Claude superpowers. You can give Claude Desktop access to your tools immediately using the built-in Connectors Directory.

• Step 1: Open Claude Desktop.
• Step 2: Look for the “Search and tools” icon near the chat input.
• Step 3: Click “Manage connectors” (or go to Settings > Connectors).
• Step 4: You will see official connectors for tools like Filesystem, Google Drive, Notion, and GitHub.
• Step 5: Select a tool (e.g., Filesystem) and Click “Install” or “Connect”.

The Result: Go back to the chat and ask: “Read the file notes.txt on my desktop and summarize it.”

Claude will instantly access the file via the connector and give you the answer. Zero coding required.

The Hero Project: Building “The Second Brain” (FastMCP 2)

Now let’s build something custom. We will build a Personal Knowledge Base Tool.

The Goal: A system that lets you save thoughts, organize notes, and recall them directly through Claude Desktop without switching apps.

• Resources: Your Agent can read your local notes.
• Tools: Your Agent can append new ideas to files.

Tech Stack: Python, uv (modern package manager), and the FastMCP 2 library.

Step 1: Setup

Open your terminal. We use uv because it is faster and cleaner than pip.

# Create a new project
uv init second-brain
cd second-brain

# Install the FastMCP 2 library
uv add fastmcp

Step 2: The Code (server.py)

We use FastMCP (v2), which removes all the boilerplate. It is the “FastAPI” of MCP.

from fastmcp import FastMCP
from datetime import datetime
import os

NOTES_DIR = "./my_notes"
if not os.path.exists(NOTES_DIR):
    os.makedirs(NOTES_DIR)

mcp = FastMCP("Second Brain")


@mcp.tool()
def list_notes() -> str:
    """List all available notes in the second brain."""
    notes = os.listdir(NOTES_DIR)
    if not notes:
        return "No notes found."
    return "Available notes:\n" + "\n".join(f"- {note}" for note in notes)


@mcp.tool()
def read_note(filename: str) -> str:
    """Read the full content of a specific note file."""
    try:
        with open(os.path.join(NOTES_DIR, filename), "r") as f:
            return f.read()
    except FileNotFoundError:
        return f"Note '{filename}' not found."


@mcp.tool()
def save_thought(filename: str, content: str) -> str:
    """Save a new thought or append to an existing note file."""
    filepath = os.path.join(NOTES_DIR, filename)
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
    with open(filepath, "a") as f:
        f.write(f"\n[{timestamp}] {content}")
    return f"Saved thought to {filename}"


@mcp.prompt()
def daily_review() -> str:
    """Returns a prompt for summarizing the day's thoughts."""
    notes = os.listdir(NOTES_DIR)
    return f"Please review the following notes: {notes}. Summarize the key ideas added today."


if __name__ == "__main__":
    mcp.run()

Step 3: Connecting Your Server

Because we are using FastMCP 2, we don’t even need to edit the config file manually!

Run this command in your terminal:

uv run fastmcp install claude-desktop server.py

The Magic:

1. Restart Claude.
2. Type: “Add a note to ideas.txt that I need to learn Rust.”
3. Check your folder. The file is there. You just gave your Agent a permanent memory.

Troubleshooting: If It Doesn’t Connect

If you see a “Connection Failed” error, Claude likely cannot find the uv tool.

Fix 1: Use the Absolute Path for uv

1. Find the path:

• Windows: where uv
• Mac/Linux: which uv

1. Update claude_desktop_config.json: Copy that path (e.g., /Users/me/.cargo/bin/uv) and paste it into the “command” field.

Fix 2: Set the Working Directory

If uv runs but fails to find server.py, explicitly tell it where to look by updating the “args” list:

"args": [
  "--directory",
  "/ABSOLUTE/PATH/TO/YOUR/PROJECT/FOLDER",
  "run",
  "server.py"
]

Going Professional: Remote & Custom Agents

Scenario A: “I need to share this tool with my team.”

Local servers (stdio) only work on your laptop. To share them, you deploy them as a Remote Server (SSE).

The Code Change:

Change just one line in your server.py:

# Old (Local)
# mcp.run()
# New (Remote)
mcp.run(transport="sse")

You can now deploy this script to AWS, Render, or Railway. It will give you a URL (e.g., https://my-notes.railway.app/sse). Your team puts that URL into their Claude config.

Scenario B: “I want to use this with my LangGraph Agent.”

You aren’t limited to Claude. You can connect this to your custom agents using langchain-mcp-adapters.

Conclusion

You are no longer just writing scripts. You are building AI Infrastructure.

By wrapping your data and tools in MCP Servers, you future-proof your work. Whether your company uses Claude today, OpenAI tomorrow, or a local Llama model next year, your tools will work with all of them, zero code changes required.

If you found this guide useful, I share more deep dives on AI infrastructure and Agentic workflows on LinkedIn. Follow along for more.

Let’s create an object using object literal as:

let a = {

id: 23,

name: 'Sam'

};

Now we will see different ways of creating object from this object:

1) Using Object.create(obj):

This way of creating object use delegation, means instead of copying object into another, this will create link/reference of old object into new object so that if requested property is not present in new object it will look up for them in old object and returns them if present.

Another advantage of delegation is that if any changes will be made in old object then those will be reflected in new object as well.

let b = Object.create(a);

console.log(a); //{id: 23, name: "Sam"}

console.log(b); //{}

In above code when we prints the ‘b’ object it will show nothing but if we request any property example ‘id’, then it will return that property from parent/old object(a).

console.log(a.id); //23

console.log(b.id); //23

Now let’s add a new property “section” in ‘a’ (old object).

a.section = 'C';

console.log(a.section); //C

console.log(b.section); //C

So here we’ve added a new property to ‘a’( old object ), and that property is also available to ‘b’( new object ).

2) Using Object.assign( {}, obj ):

This way will create the object by simply copying all the properties from old object to new object, this can also be said as 1-time copying, means if any changes will be made in old object, those changes will not be reflected in new object.

let c = Object.assign({}, a);

console.log(a); //{id: 23, name: "Sam"}

console.log(c); //{id: 23, name: "Sam"}

In above code if we print ‘c’(new object) then this will print all the properties that are present in ‘a’(old object), that means all the properties are copied from ‘a’ to ‘c’ object and there is no delegation present.

console.log(a.id); //23

console.log(c.id); //23

Now let’s add a new property in ‘a’(old object).

a.year = 2018;

console.log(a.year); //2018

console.log(c.year); //undefined

Now here we’ve added ‘year’ property to ‘a’(old object) but if we try to request that property using ‘c’ object then it will prints undefined, since the changes made to old object can’t be reflected to new object.

3) JSON’s parse() and stringify():

JSON’s parse(string) converts the string into JavaScript object.

JSON’s stringify(object) converts the JavaScript object into string.

so we will use these two methods to create a new object from old object. We first convert the old object into string using stringify() method, then we convert this string into JavaScript object using parse() method.

let d = JSON.parse(JSON.stringify(a));

console.log(a); //{id: 23, name: "Sam"}

console.log(d); //{id: 23, name: "Sam"}

console.log(a.id); //23

console.log(d.id); //23

we can also say this way as 1-time copy, as in above code when we prints ‘d’(new object) it will prints all the properties, now if we make any changes to ‘a’(old object) then these changes will not be available in ‘d’(new object).

a.grade = 'A+';

console.log(a.grade); //A+

console.log(d.grade); //undefined

As we can see we’ve added ‘grade’ property to ‘a’(old object), but it’s not available in ‘d’(new object).

This is all about the different ways of creating an object from another object.

Hope this might have helped you to understand JavaScript better