Search for a command to run...
MCP provides a unified and standardized framework for connecting LLM with external data and tools.
Widely known as fotiecodes, an open source enthusiast, software developer, mentor and SaaS founder. I'm passionate about creating software solutions that are scalable and accessible to all, and i am dedicated to building innovative SaaS products that empower businesses to work smarter, not harder.
No comments yet. Be the first to comment.
Lisbon, If you have ever been here, you know the streets are a wild mix of steep hills, narrow cobblestone alleys, and confusing one-way roads. Navigating this city takes serious skill. The yellow tra
If you have been paying attention to the AI space for the last few months, you know the fatigue is real. We have spent three years typing into a box, getting a paragraph of text back, copying it, past
I have always wondered how Apple does their spatial photos on iOS and especially on the new Apple Vision Pro. If you have tried the headset, or even just tilted your phone while looking at a "spatial" capture, you know that weird, distinct feeling of...
Understand the distinctions between Retrieval and Cache-Augmented Generation; find out how CAG improves speed while RAG handles real-time information
I’m sitting here with a hot cup of coffee, about halfway through Google’s new paper on "Nested Learning," and I have to be honest: I need to get this out of my head and onto the screen. Usually, when a big lab drops a paper, I skim the abstract, nod ...
Integrating Large Language Models (LLMs) with external systems has transformed how businesses interact with technology. These models enable natural language inputs to control software, streamlining workflows and making operations more intuitive. However, integrating LLMs with external tools requires two key processes:
Translating user prompts into structured function calls (Function Calling).
Executing those function calls within an organized system (Model Context Protocol or MCP).
Both Function Calling and MCP play essential roles in LLM-driven automation. While Function Calling focuses on converting natural language into action-ready commands, MCP ensures those commands are executed efficiently and consistently. Let’s break down their differences and how they work together.
Before we begin, if you’re working with LLMs and need help setting up Function Calling, integrating MCP, or making your AI-driven system more efficient, I’d love to help. Whether you’re building something from scratch or improving an existing setup, having the right structure in place can save you a lot of time and effort.
If you’re looking for guidance or want to make sure everything runs smoothly, feel free to reach out at hello@fotiecodes.com, let’s chat about how we can get your AI system working exactly the way you need it to.
LLMs interact with external systems through a two-phase approach:
Function Calling enables LLMs to transform a user’s input into a structured function call. For example, if someone asks, "What’s Apple’s stock price in USD?", the LLM generates a function call containing the necessary details (company name, currency format) for retrieving stock data.
Different LLM providers have their own way of structuring these function calls. Here’s how major models handle it:
OpenAI:
{
"index": 0,
"message": {
"role": "assistant",
"content": null,
"tool_calls": [
{
"name": "get_current_stock_price",
"arguments": "{\n \"company\": \"AAPL\",\n \"format\": \"USD\"\n}"
}
]
},
"finish_reason": "tool_calls"
}
Claude:
{
"role": "assistant",
"content": [
{
"type": "text",
"text": "<thinking>To answer this question, I will: …</thinking>"
},
{
"type": "tool_use",
"id": "1xqaf90qw9g0",
"name": "get_current_stock_price",
"input": {"company": "AAPL", "format": "USD"}
}
]
}
Gemini:
{
"functionCall": {
"name": "get_current_stock_price",
"args": {
"company": "AAPL",
"format": "USD"
}
}
}
LLaMA:
{
"role": "assistant",
"content": null,
"function_call": {
"name": "get_current_stock_price",
"arguments": {
"company": "AAPL",
"format": "USD"
}
}
}
Each model formats function calls differently, meaning there’s no universal standard yet. However, tools like LangChain help developers work with multiple LLMs by handling these variations.
Once an LLM generates a function call, that request needs to be executed by an external system. MCP provides a structured framework for handling these function calls, ensuring that tools can consistently interpret and respond to LLM-generated instructions.
MCP acts as a bridge between LLMs and software systems by managing:
Tool discovery: Identifying the right tool for the request.
Invocation: Executing the function call.
Response handling: Returning results in a structured format.
Here’s what an MCP request looks like:
{
"jsonrpc": "2.0",
"id": 129,
"method": "tools/call",
"params": {
"name": "get_current_stock_price",
"arguments": {
"company": "AAPL",
"format": "USD"
}
}
}
In this setup, the application acts as a mediator that translates an LLM’s output into an MCP-compatible request. MCP then ensures the function call is executed correctly, sending structured results back to the LLM.
Though both Function Calling and MCP help LLMs interact with external systems, they serve distinct purposes.
| Feature | Function Calling | MCP (Model Context Protocol) |
| Purpose | Converts user prompts into structured function calls. | Standardizes execution and response handling. |
| Who Controls It? | LLM provider (e.g., OpenAI, Anthropic, Google). | External system handling LLM integration. |
| Output Format | Varies by LLM vendor (JSON-based). | Uses a standardized protocol (e.g., JSON-RPC). |
| Flexibility | Different models structure calls differently. | Ensures interoperability across multiple tools. |
Essentially, Function Calling is about “ordering the task,” while MCP is responsible for “executing the task.” Together, they ensure that AI-driven software automation runs efficiently.
Well, I believe it’s crucial for companies integrating LLMs into their workflows to understand the difference between Function Calling and MCP. Here’s why:
Scalability: MCP allows businesses to integrate LLMs across multiple applications, ensuring seamless function execution.
Standardization: Instead of dealing with different LLM formats, MCP provides a consistent execution framework.
Flexibility: Even as LLM vendors change their function call formats, MCP ensures continued compatibility with tools.
As AI adoption grows, businesses that leverage Function Calling + MCP together will have a more efficient and scalable AI-powered infrastructure.
In a nutshell both Function Calling and MCP play essential roles in enabling AI-driven software apps. While Function Calling translates natural language prompts into structured instructions, MCP ensures those instructions are executed consistently and reliably.
For companies looking to integrate AI into their workflows, understanding this two-phase approach will be key to maximizing efficiency and long-term scalability. As LLMs continue to evolve, having a robust Function Calling + MCP integration will be a game-changer in enterprise AI adoption.
1. What is Function Calling in LLMs?
Function Calling allows LLMs to convert user inputs into structured API requests, enabling AI-powered automation.
2. What does MCP do?
MCP (Model Context Protocol) manages the execution of LLM-generated function calls by standardizing how software tools process these requests.
3. Why do Function Calling and MCP need each other?
Function Calling translates prompts into structured instructions, while MCP executes them, ensuring seamless AI integration.
4. Can I use Function Calling without MCP?
Yes, but without MCP, handling function execution across multiple tools becomes inconsistent and less scalable.
5. Will there be a universal standard for Function Calling?
Currently, there’s no single standard, but frameworks like LangChain help manage multiple LLM formats effectively.