Both MCP and function calling let LLMs interact with external tools. They solve the same problem differently. Here’s when to use each.

The difference

Function calling is built into the LLM API. You define functions in your request, the model decides when to call them, and you execute them in your code.

# Function calling: defined per request, executed by YOUR code
response = client.chat.completions.create(
    model="claude-sonnet-4.6",
    messages=messages,
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}
        }
    }]
)
# You execute the function and return the result

MCP is a protocol that connects LLMs to external tool servers. Tools are defined by the server, discovered dynamically, and can be shared across applications.

# MCP: tools defined by external server, discovered at runtime
# The MCP server exposes tools via a standardized protocol
# Any MCP-compatible client can use them

When to use function calling

• Simple tools — 1-5 functions specific to your app
• Tight integration — tools are part of your application logic
• Single application — tools aren’t shared across apps
• Maximum control — you control exactly which tools are available

Example: A chatbot that can look up orders, check inventory, and process refunds. These functions are specific to your app and don’t need to be shared.

When to use MCP

• Reusable tools — tools shared across multiple applications
• Third-party integrations — connecting to external services (Slack, GitHub, databases)
• Dynamic tool discovery — tools change without redeploying your app
• Ecosystem — you want to use community-built MCP servers

Example: An AI coding assistant that needs to access GitHub, read databases, search documentation, and send Slack messages. Each is a separate MCP server that any AI tool can use.

Side-by-side comparison

	Function calling	MCP
Defined by	Your code	External server
Discovery	Static (per request)	Dynamic (at runtime)
Sharing	Not shareable	Shareable across apps
Setup	Add to API call	Run MCP server + connect
Complexity	Low	Medium
Ecosystem	None	Growing (best MCP servers)
Security	You control everything	Need to trust MCP server (security guide)
Supported by	All major LLM APIs	Claude, GPT, Gemini, coding tools

Can you use both?

Yes. Many production systems use function calling for app-specific tools and MCP for external integrations:

# App-specific tools via function calling
tools = [
    {"function": {"name": "search_products", ...}},
    {"function": {"name": "create_order", ...}},
]

# External tools via MCP
mcp_tools = mcp_client.list_tools()  # GitHub, Slack, etc.
tools.extend(mcp_tools)

response = call_llm(messages, tools=all_tools)

The practical recommendation

Situation	Use
Building a simple AI feature	Function calling
Building an AI coding tool	MCP (access filesystem, git, terminal)
Integrating with 3rd party services	MCP
Internal business logic	Function calling
Want community tools	MCP
Maximum simplicity	Function calling

Start with function calling. It’s simpler and built into every LLM API. Add MCP when you need reusable tools, third-party integrations, or want to tap into the MCP ecosystem.

See our tool calling patterns guide for implementation patterns and MCP security checklist for securing tool access.

Related: MCP Complete Developer Guide · Tool Calling Patterns · What is Tool Calling? · Best MCP Servers · MCP Security Checklist · What is A2A Protocol?