What Is an MCP Server? Voice Agents Explained
Jaseem Abbas
- Published

An MCP server is a program that offers tools and data to an AI application using the Model Context Protocol, an open standard for connecting AI applications to outside systems. This guide explains what an MCP server is, what it can offer, how it talks to an AI app, how it differs from a plain API, and what it means for a phone agent that has to answer while a caller waits.
Here is a small story. Kavita runs support for a furniture shop in Jaipur. Her tech lead, Rohan, built an MCP server last month so the shop's chat assistant could look up orders. It offers two tools, get_order_status and list_delivery_slots. Now Kavita wants her phone agent to use the same tools, so a caller who says "mera sofa kab aayega?" gets a real answer. Rohan does not want to write a second integration. He does not have to, because the server already speaks MCP. Kavita, Rohan, the shop and the tool names are made up for this example. They are not customers.
What is an MCP server?
An MCP server is a service that exposes tools, data and prompt templates to an AI application through the Model Context Protocol. The protocol's own introduction calls MCP "an open-source standard for connecting AI applications to external systems", and compares it to a USB-C port for AI applications (Model Context Protocol introduction, read 16 November 2026).
Before MCP, each AI product needed its own custom plug for each system it wanted to reach. Anthropic, which open-sourced the protocol, describes the problem this way: every new data source needed its own implementation, which made connected systems hard to scale (Anthropic's announcement of MCP, read 16 November 2026). MCP replaces those one-off plugs with one protocol, so a server written once can work with any application that speaks it.
Our glossary has a short definition of an MCP server if you only need the term. This post goes further.
What are the host, the client and the server?
MCP has three roles. The host is the AI application, the client is the connector inside the host, and the server is the program that offers the tools. The specification lists them this way: "Hosts: LLM applications that initiate connections", "Clients: Connectors within the host application" and "Servers: Services that provide context and capabilities" (MCP specification, revision of 28 July 2026, read 16 November 2026).
The messages between them use JSON-RPC 2.0, a simple format where a request names a method and its parameters, and the reply carries the result. You rarely write these by hand. Official SDKs do it for you.
Two examples make the roles concrete. When you use Claude Code and connect it to a server, Claude Code is the host. When a Bananaflow phone agent calls your order lookup during a call, the agent is the host and your server is the server.
What are tools, resources and prompts?
They are the three things a server can offer, and each one is controlled by someone different. The specification describes tools as model-controlled, resources as application-driven, and prompts as user-controlled. That one idea explains most design choices.
Feature: Tools
- What it is
- Functions the model can run
- Who decides to use it
- The model, from the conversation
- Example for Kavita's shop
- get_order_status(order_id)
Feature: Resources
- What it is
- Data with an address, such as a file or a schema
- Who decides to use it
- The application
- Example for Kavita's shop
- The delivery policy document
Feature: Prompts
- What it is
- Templates for messages and workflows
- Who decides to use it
- The user, for example from a slash command
- Example for Kavita's shop
- A "write a refund reply" template
Tools are the part voice agents use most. The specification says "Tools in MCP are designed to be model-controlled, meaning that the language model can discover and invoke tools automatically based on its contextual understanding and the user's prompts" (MCP tools). Each tool has a name, a description, and an inputSchema, which is a JSON Schema that says what arguments it takes. The host asks for the list with tools/list and runs one with tools/call.
Resources are data that give the model context, such as files or database schemas. Each one has an address, a URI, and the host decides how to include it (MCP resources). A phone agent mostly does not need them, because it asks live questions instead of reading documents.
Prompts are templates a user picks on purpose. The specification calls them "user-controlled", which means the user chooses when to use one, while the server writes its content (MCP prompts).
How do stdio and Streamable HTTP differ?
With stdio, the host starts the server as a program on the same machine and talks to it through standard input and output. With Streamable HTTP, the server runs somewhere on the network and the host sends it HTTP requests. Pick stdio for tools on your own laptop. Pick Streamable HTTP for anything a phone agent in the cloud has to reach.
The specification defines these two as its standard transports (MCP transports). A transport only carries messages. The meaning of the messages is the same on both.
: Where the server runs
- stdio
- A subprocess that the client launches
- Streamable HTTP
- An independent process that can serve many clients
: How messages travel
- stdio
- Newline-delimited JSON-RPC over standard input and output
- Streamable HTTP
- Each message is an HTTP POST to one MCP endpoint
: How replies arrive
- stdio
- Lines written to standard output
- Streamable HTTP
- A single JSON object, or a Server-Sent Events stream for that request
: Typical use
- stdio
- A local tool on your own machine
- Streamable HTTP
- A remote server that several people or agents share
: Security notes in the specification
- stdio
- The server must write only valid MCP messages to standard output
- Streamable HTTP
- Validate the Origin header, bind to localhost when running locally, and authenticate connections
The sources for the table are the stdio page and the Streamable HTTP page. Streamable HTTP arrived in an earlier revision (2025-03-26) to replace the older HTTP plus SSE transport, and the 28 July 2026 revision changed how it behaves. The new revision removed protocol-level sessions, so each request stands alone. If you built a server against an older revision, read the changelog before you assume it still works.
The specification adds that the HTTP transport mirrors some request details into HTTP headers, so that proxies and load balancers can route a request without reading its body. That suits a phone agent that makes many calls at once.
What is the difference between MCP, a REST API and function calling?
They sit at different levels, so they are not rivals. A REST API is a way to expose your system to programmers. Function calling is how a language model asks for a tool. MCP is the standard that lets a server describe its tools in a form a model can read, so any host can list and run them.
Here is the same order lookup three ways.
: What it is
- Plain REST API
- An endpoint, like GET /orders/1042
- Function calling
- The model's request to run a function
- MCP server
- A standard way for a server to list and run tools
: Who reads the description
- Plain REST API
- A developer, in your docs
- Function calling
- The model, from a schema your app sends it
- MCP server
- The model, from the tool list the server returns
: Who writes the glue
- Plain REST API
- Each app that calls it
- Function calling
- Each app, for each provider
- MCP server
- Written once, in the server
: Tool list changes
- Plain REST API
- Update every app that calls it
- Function calling
- Update every app that defines the function
- MCP server
- The server lists the current tools when asked
Anthropic's documentation says tool use is also called function calling, and that Claude asks for a tool while your code runs it (Anthropic tool use docs, read 16 November 2026). OpenAI describes the same loop in five steps: send tools with the request, receive a tool call, run the code, send the output back, and receive the final answer (OpenAI function calling guide, read 16 November 2026).
An MCP server often sits in front of a REST API. It wraps the endpoint in a tool with a clear name, a plain description and a schema. For a deeper look at the model side, see our function calling glossary entry, and for the voice side see tool calling on live voice calls.
How does a voice agent use an MCP server during a call?
The agent lists the server's tools, picks one when the caller needs it, sends the arguments, waits for the result, and then says the answer. This happens in the middle of a live call, with the caller listening.
Take Kavita's call. A caller says, "Mera order number 1042 hai, kab aayega?" The agent decides get_order_status fits, sends {"order_id": "1042"}, and gets back a status and a date. It then says the date in a sentence, in Hindi or English, whichever the caller used.
On Bananaflow, an agent can use your own MCP servers as one of its tools. You paste the server's URL and pick a credential, and Refresh lists the tools it offers. You then allow only the tools you want, and you choose again for each step of the call. The server must support Streamable HTTP. If the server is down, the call carries on without its tools. The integrations page shows how this looks.
What does latency mean for an MCP tool on a call?
Every tool call adds the time the tool takes, and on a phone call that time is silence. A caller does not see a spinner. They hear nothing, and after a second or two they say "hello?".
Our voice agent latency guide breaks the reply time into its parts. A tool call is one more part, and it is the one you control most. Four habits help:
- Allow fewer tools per step. A step that only collects a name does not need a booking tool. Fewer choices also help the model pick the right one.
- Keep each tool quick. If a job is slow, make the tool start it and return an id, then add a second tool that checks the result.
- Return short answers. A tool that sends back a whole customer record gives the model more to read and more to get wrong. Send the fields the agent will say.
- Time the tool before real calls. Our post on how to test a voice agent covers testing by voice. Time every tool the same way a caller would feel it.
We cover what the agent should say while it waits in tool calling on live voice calls.
How does a coding assistant use Bananaflow's MCP server?
It connects to Bananaflow's MCP server so you can build and test voice agents by describing them in a chat. This is the second direction in the figure above. Here MCP is how you build the agent, not something the caller touches.
Bananaflow runs an MCP server at https://app.bananaflow.ai/api/v1/mcp/. It uses the Streamable HTTP transport, and it reads your API key from an X-API-Key header. An assistant such as Claude Code, Codex, Claude Desktop or Cursor can create, edit, test and evaluate voice agents and their tools through it. The setup steps and the full tool list are in Bananaflow's MCP setup guide, and our walk-through is in Claude Code MCP: build voice agents by chat.
What should you expose on an MCP server, and how do you secure it?
Expose only what an agent needs, check every input, and treat the server like any public API. The MCP specification does not secure your server for you. It says servers must "validate all tool inputs", "implement proper access controls", "rate limit tool invocations" and "sanitize tool outputs" (MCP tools, security considerations).
For a phone agent, we suggest this short checklist:
- Split reads from writes. A lookup is low risk. A cancellation or a refund is not. Give the agent the lookup first, and add a write tool only when a step needs it.
- Describe each tool for the model, in plain words. Say what it does, what each argument means and what it returns. The model chooses tools from these descriptions.
- Authenticate every call. For Streamable HTTP, the specification says servers should implement proper authentication and must validate the
Originheader (Streamable HTTP transport). - Give each agent its own credential. Then you can switch one off without breaking the others.
- Do not trust what comes back from other servers. The specification says clients must treat tool annotations as untrusted unless they come from trusted servers. Connect only servers you trust.
- Keep a human in the loop for risky actions. The specification says there should always be a human who can deny a tool call. On a call, that usually means the agent confirms with the caller first, or hands off to a person.
Our guide to AI voice agent guardrails goes further on what the agent should refuse, confirm or pass to a person.
How does Bananaflow fit?
Bananaflow is an AI voice agent platform. An agent can use HTTP API tools you test first, your own MCP servers, 100+ apps in one click, transfer to a person or another agent, and end call. Bananaflow also runs its own MCP server, so a coding assistant can build the agent for you. You build in a visual workflow builder, and a booking flow like the one in appointment booking calls can use a tool from your own server.
What should you remember about MCP servers?
- An MCP server offers tools, resources and prompts to an AI application over one open protocol.
- Tools are model-controlled, resources are application-driven and prompts are user-controlled.
- Use stdio for a local server and Streamable HTTP for a remote one.
- MCP and function calling work together. Function calling is the model's request, and MCP is the standard way a server lists and runs tools.
- On a call, tool time is silence. Allow few tools per step, keep them quick and test them by voice.
- Validate inputs, check access and keep keys secret. The protocol does not do it for you.
FAQ
Frequently asked questions
What is an MCP server?
An MCP server is a program that offers tools, data and prompt templates to an AI application using the Model Context Protocol, an open standard. The AI application is called the host. Write the server once and any host that speaks MCP can list its tools and use them.
What are tools, resources and prompts in MCP?
Tools are functions the model can run, such as an order lookup. Resources are data with an address, such as a file, that the application can read. Prompts are message templates that a user picks on purpose. The specification says tools are model-controlled, resources are application-driven and prompts are user-controlled.
What is the difference between stdio and Streamable HTTP?
With stdio, the host starts the server as a program on the same machine and talks to it through standard input and output. With Streamable HTTP, the server runs on the network and each message is an HTTP POST to one endpoint. Use stdio for local tools and Streamable HTTP for a server a cloud phone agent has to reach.
Is MCP the same as an API?
No. A REST API is an endpoint written for programmers. An MCP server wraps tools in a form a model can read, with a name, a plain description and an input schema, so any host can list and run them. Many MCP servers sit in front of an existing API.
Is MCP the same as function calling?
No, they work together. Function calling is what the model does when it asks for a tool to be run. MCP is a standard way for a server to list its tools and run them. A host reads the tool list from the MCP server, gives it to the model, and sends the model's request back to the server.
Can a phone agent use an MCP server during a call?
Yes. On Bananaflow you add your server's URL as a tool, pick a credential, and Refresh lists its tools. You allow only the tools you want and choose again for each step of the call. The server must support Streamable HTTP. If the server is down, the call carries on without its tools.
Is an MCP server safe to expose?
Only if you secure it. The specification says servers must validate all tool inputs, implement access controls, rate limit tool calls and sanitize outputs, and Streamable HTTP servers should authenticate every connection. Expose only the tools an agent needs, keep keys out of chats and Git, and confirm risky actions with the caller.




