MCP vs REST APIs vs Function Calling

| Feature              | REST APIs          | Function Calling     | MCP                    |
|----------------------|--------------------|----------------------|------------------------|
| Who calls it?        | Your app code      | The AI model         | The AI model           |
| Discovery            | Read docs manually | Hardcoded in prompt  | Dynamic at runtime     |
| Protocol             | HTTP + JSON        | Provider-specific    | JSON-RPC 2.0           |
| Standardized?        | Loosely (OpenAPI)  | No (per-provider)    | Yes (open spec)        |
| Stateful?            | Usually no         | Per-conversation     | Yes (session-based)    |
| Bidirectional?       | Request/Response   | Request/Response     | Full bidirectional     |
| Multi-provider?      | N/A                | Lock-in              | Any MCP-compatible AI  |

import requests
import openai

# Step 1: User asks "What's the weather in Tokyo?"
user_question = "What's the weather in Tokyo?"

# Step 2: Your app code decides to call a weather API
# YOU write this logic - the AI doesn't choose this
response = requests.get(
    "https://api.weatherapi.com/v1/current.json",
    params={"key": "YOUR_API_KEY", "q": "Tokyo"}
)
weather_data = response.json()

# Step 3: You manually inject the result into the AI prompt
completion = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": f"Current weather data: {weather_data}"},
        {"role": "user", "content": user_question}
    ]
)

# This is what REST + AI integration looks like at scale
# It becomes a massive if/else tree

if "weather" in user_message:
    data = call_weather_api(extract_city(user_message))
elif "stock" in user_message:
    data = call_stock_api(extract_ticker(user_message))
elif "email" in user_message:
    data = call_email_api(extract_email_params(user_message))
elif "calendar" in user_message:
    data = call_calendar_api(extract_date(user_message))
# ... this never ends

import openai

# Define tools the AI can use
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# The AI decides whether and how to call the function
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools
)

# If the AI chose to call a function:
tool_call = response.choices[0].message.tool_calls[0]
# tool_call.function.name == "get_weather"
# tool_call.function.arguments == '{"city": "Tokyo"}'

# YOU still execute it and return the result
weather = get_weather(city="Tokyo")  # Your implementation

# Send the result back to the AI
follow_up = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "What's the weather in Tokyo?"},
        response.choices[0].message,
        {"role": "tool", "tool_call_id": tool_call.id, "content": str(weather)}
    ],
    tools=tools
)

Problem 1: PROVIDER LOCK-IN
=================================
OpenAI function calling format:
  {"type": "function", "function": {"name": "...", ...}}

Anthropic tool use format:
  {"name": "...", "input_schema": {...}}

Google Gemini format:
  {"function_declarations": [{"name": "...", ...}]}

Each provider uses a different format. Your tool definitions
are NOT portable. Switch providers? Rewrite everything.


Problem 2: STATIC DEFINITIONS
=================================
Tools are defined at the START of a conversation.
They are literally embedded in the prompt. You cannot:
  - Add new tools mid-conversation
  - Discover tools dynamically
  - Share tools between applications


Problem 3: NO STANDARD EXECUTION LAYER
=================================
The AI says "call get_weather with city=Tokyo"
But YOU must implement get_weather()
And YOU must wire the result back
There is no standard for HOW tools are executed

# Server side - define a tool ONCE
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Weather Service")

@mcp.tool()
async def get_weather(city: str) -> str:
    """Get current weather for a city.

    Args:
        city: The city name to look up weather for
    """
    # Your actual implementation
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"https://api.weatherapi.com/v1/current.json",
            params={"key": API_KEY, "q": city}
        )
        data = resp.json()
        return f"{data['current']['temp_c']}C, {data['current']['condition']['text']}"

# Any MCP-compatible AI can discover and use this tool.

FUNCTION CALLING:
  App defines tools -> Embeds in prompt -> AI chooses -> App executes
  (Everything lives in YOUR application)

MCP:
  Server exposes tools -> Client discovers them -> AI chooses -> Server executes
  (Tools live in independent servers, reusable by ANY client)

// With MCP, the AI discovers tools at RUNTIME
// Client sends:
{"jsonrpc": "2.0", "method": "tools/list", "id": 1}

// Server responds with all available tools:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "inputSchema": {
          "type": "object",
          "properties": {
            "city": {"type": "string", "description": "City name"}
          },
          "required": ["city"]
        }
      }
    ]
  }
}

MCP tool definition works with:
  - Claude Desktop
  - Cursor IDE
  - VS Code Copilot
  - Windsurf
  - Any MCP-compatible host

Function calling tool definition works with:
  - Only the specific provider you wrote it for

# TOOLS - Actions the AI can take (like function calling)
@mcp.tool()
def search_database(query: str) -> str:
    """Search the product database."""
    return db.search(query)

# RESOURCES - Data the AI can read (like a file system)
@mcp.resource("config://settings")
def get_settings() -> str:
    """Application settings the AI can reference."""
    return json.dumps(app_settings)

# PROMPTS - Reusable prompt templates
@mcp.prompt()
def analyze_data(dataset: str) -> str:
    """Template for data analysis tasks."""
    return f"Analyze this dataset thoroughly: {dataset}"

REST API:       Each request is independent (stateless)
Function Call:  State lives in conversation context only
MCP:            Persistent session with the server

MCP servers can maintain state across multiple tool calls:
  Call 1: connect_to_database("production")  -> Session established
  Call 2: run_query("SELECT * FROM users")   -> Uses same connection
  Call 3: run_query("SELECT * FROM orders")  -> Still same connection

// Server notifies client that available tools have changed
{
  "jsonrpc": "2.0",
  "method": "notifications/tools/list_changed"
}

// Server can request the AI to sample (generate text)
{
  "jsonrpc": "2.0",
  "method": "sampling/createMessage",
  "params": {
    "messages": [{"role": "user", "content": "Summarize this data..."}],
    "maxTokens": 500
  }
}

# You write ALL the orchestration logic
def review_pr(pr_number):
    # Fetch PR details
    pr = requests.get(
        f"https://api.github.com/repos/owner/repo/pulls/{pr_number}"
    ).json()

    # Fetch the diff
    diff = requests.get(pr["diff_url"]).text

    # Fetch related files for context
    files = requests.get(f"{pr['url']}/files").json()

    # Fetch previous review comments
    comments = requests.get(f"{pr['url']}/comments").json()

    # Manually construct the prompt with all this context
    prompt = f"""Review this PR:
    Title: {pr['title']}
    Diff: {diff}
    Files changed: {json.dumps(files)}
    Previous comments: {json.dumps(comments)}
    """

    # Send to AI
    review = call_ai(prompt)

    # Post the review back (more REST calls)
    requests.post(f"{pr['url']}/reviews", json={"body": review})

# Better - AI decides what info it needs
tools = [
    make_tool("get_pr_details", "Get PR info", {"pr_number": "integer"}),
    make_tool("get_pr_diff", "Get the diff", {"pr_number": "integer"}),
    make_tool("get_file_content", "Read a file", {"path": "string"}),
    make_tool("post_review", "Post review", {"pr_number": "integer", "body": "string"}),
]

# Still need to implement each function yourself
# Still locked to one AI provider
# Tool definitions are static

// In Claude Desktop config, just add:
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token"
      }
    }
  }
}

// Claude now has full GitHub access.
// It discovers and uses all GitHub tools automatically.
// No glue code. No custom implementations.

Decision flowchart:

Does the AI need to choose which actions to take?
  No  -> Use REST APIs
  Yes -> Do you need portability across AI providers?
           No  -> Function calling may suffice
           Yes -> Use MCP