Agent Series (10): MCP Protocol — Standardizing the Tool Ecosystem

@tool
def search_jira(query: str) -> str:
    """Search Jira tickets"""
    ...
 
@tool
def query_database(sql: str) -> str:
    """Execute a SQL query"""
    ...
 
agent = create_react_agent(model=llm, tools=[search_jira, query_database, ...])

┌────────────────────────────────────────────────────────────────┐
│                      MCP Architecture                           │
├──────────────────┬──────────────────────────────────────────────┤
│ Host             │ The environment hosting the Agent:           │
│                  │ Claude Desktop, Claude Code, custom apps     │
│                  │ Contains one or more MCP Clients             │
├──────────────────┼──────────────────────────────────────────────┤
│ Client           │ Protocol client embedded in the Host         │
│                  │ Manages connections and communication        │
│                  │ with MCP Servers                             │
├──────────────────┼──────────────────────────────────────────────┤
│ Server           │ Independent process exposing Tools           │
│                  │ Can also expose Resources and Prompts        │
└──────────────────┴──────────────────────────────────────────────┘
 
Transport options:
  Local:  stdio (subprocess stdin/stdout)
  Remote: HTTP + SSE (Server-Sent Events)

@lc_tool
def calculator(expression: str) -> str:
    """Evaluate a simple arithmetic expression."""
    ...
 
@lc_tool
def text_stats(text: str) -> str:
    """Return word count, sentence count, and character count."""
    ...
 
@lc_tool
def weather_mock(city: str) -> str:
    """Return mock weather data for a city."""
    ...
 
traditional_tools = [calculator, text_stats, weather_mock]
agent = create_react_agent(model=llm, tools=traditional_tools)

Q: What is 2 ** 10 + 100 / 4?
A: The result of 2 ** 10 + 100 / 4 is 1049.0.
 
Q: Analyze this text: 'Python is elegant. It is readable. Everyone loves it!'
A: 9 words, 3 sentences, 53 characters.
 
Q: What's the weather in Beijing?
A: sunny, 25°C, humidity 40%.

Tools defined in THIS file: ['calculator', 'text_stats', 'weather_mock']
 
If Agent B also needs these tools:  copy-paste or re-import
If you update calculator's logic:   find every Agent file that uses it
If the tools are written in TypeScript:  this approach doesn't work at all

# tools_server.py
from mcp.server.fastmcp import FastMCP
 
mcp = FastMCP("demo-tools")
 
@mcp.tool()
def calculator(expression: str) -> str:
    """Evaluate a simple arithmetic expression (e.g. '2 ** 10', '100 / 7')."""
    ...
 
@mcp.tool()
def text_stats(text: str) -> str:
    """Return word count, sentence count, and character count for the given text."""
    ...
 
@mcp.tool()
def weather_mock(city: str) -> str:
    """Return mock weather data for a city (demo only — not real data)."""
    ...
 
if __name__ == "__main__":
    mcp.run(transport="stdio")

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
 
server_params = StdioServerParameters(command="python", args=["tools_server.py"])
 
async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
 
        # Dynamic discovery — no tool names hardcoded in client code
        tools_result = await session.list_tools()

Server: demo-tools
Discovered 3 tools:
  ● calculator       — Evaluate a simple arithmetic expression (e.g. '2 ** 10', '100 / 7').
  ● text_stats       — Return word count, sentence count, and character count for the given text.
  ● weather_mock     — Return mock weather data for a city (demo only — not real data).

calculator('2 ** 10 + 100 / 4')  → 2 ** 10 + 100 / 4 = 1049.0
weather_mock('Shanghai')          → {"city": "Shanghai", "temp": 22, "condition": "cloudy", "humidity": 75}
text_stats(...)                   → {"words": 9, "sentences": 3, "chars": 53}

from langchain_mcp_adapters.client import MultiServerMCPClient
 
client = MultiServerMCPClient(
    {
        "demo-tools": {
            "command": "python",
            "args": ["tools_server.py"],
            "transport": "stdio",
        }
    }
)
mcp_tools = await client.get_tools()
# → ['calculator', 'text_stats', 'weather_mock']
# Tool definitions live in the Server, not in this file
 
agent = create_react_agent(model=llm, tools=mcp_tools)
result = await agent.ainvoke({"messages": [HumanMessage(multi_q)]})

Questions:
  1. What is sqrt(144) + 2 ** 8?
  2. What's the weather in Shenzhen?
  3. Count the stats for: 'MCP is a protocol. It standardizes tools. Agents love it!'
 
Answers:
  1. The result of sqrt(144) + 2 ** 8 is 260.
  2. (LLM called weather_mock, but added a "not real-time data" disclaimer
       because the tool description says "demo only")
  3. word count: 15, sentence count: 1, character count: 52

Dimension           Function Calling               MCP
──────────────────────────────────────────────────────────────────────
Tool definition     In Agent code                  In independent MCP Server
Tool discovery      Hardcoded import               list_tools() (dynamic)
Multi-agent reuse   Copy-paste or re-import        All Agents connect to same Server
Update tool logic   Edit every Agent file          Edit Server only
Cross-language      Same language only             Any language (JSON-RPC)
Invocation          In-process function call       Cross-process JSON-RPC
Startup overhead    None                           subprocess launch
Best fit            Single Agent / small projects  Multi-Agent / team collaboration

Official MCP Servers (@modelcontextprotocol/):
  server-filesystem   — local file read/write
  server-github       — GitHub repo, issues, PR operations
  server-postgres     — PostgreSQL queries
  server-brave-search — web search (requires Brave API key)
 
Community maintained:
  Search "awesome-mcp-servers" for the full list
  Includes: Jira, Slack, Notion, Linear, Figma, and dozens more
 
Claude Code's tools are MCP:
  → file read/write, terminal commands, code search…
  → all run through this same protocol