Model Context Protocol (MCP) lets your phone's AI assistant talk to remote servers and APIs without uploading your questions to the cloud. MyBenAI uses MCP connectors to extend your local AI with custom tools, databases, and integrations—all coordinated on your device. Here's how the architecture works and what you can build with it.
What Is the Model Context Protocol?
The Model Context Protocol (MCP) is a standard for connecting LLMs to external systems. Instead of baking every possible tool into an AI app, MCP lets the AI ask remote servers for capabilities: "Can you fetch this database record?" or "Do you have a tool to send emails?" The remote server responds with the tool's schema (what inputs it needs, what outputs it returns), and the local AI orchestrates the call.
Think of MCP as a contract. The local AI says "I need a tool to do X." The remote server says "I have that tool; here's what you need to send me." The AI sends the request, the server handles it, and the result comes back to your phone. All of this happens programmatically—the LLM decides when and how to use each tool based on the conversation.
MCP is not new; it was designed by Anthropic as an open standard and is already used in Claude Desktop, IDEs, and other applications. MyBenAI brings MCP to your phone, letting you connect to remote services while keeping your message content private and on-device.
How MCP Differs From Cloud AI Integration
When you use ChatGPT's plugins or Claude's integrations, you're relying on Anthropic's or OpenAI's servers to proxy the connection. They see your request, they call the external service, they return the result. Your query and context flow through their systems.
With MyBenAI's MCP connectors, the orchestration happens on your phone. Your AI runs locally on your device, decides it needs a tool, constructs a request based on your conversation, and sends that request directly to the remote MCP server. The remote server never sees your full conversation history—only the specific parameters it needs to fulfill the tool call. Your message content stays private.
This architectural difference matters for privacy. A MCP connector can connect to your own home server, a private database, or a third-party API. The remote server handles the call, but your context never leaves your device. You decide which connectors to trust and which tools each connector can use.
MCP Server Architecture: What Runs Where
An MCP setup has three parts:
- Local AI (your phone): Runs your conversation, interprets your questions, decides when to call tools.
- MCP client (MyBenAI): Manages connections to remote MCP servers, translates tool calls, formats requests.
- MCP server (remote): Exposes tools and APIs; handles the actual work (database queries, API calls, file operations, etc.).
The local AI never directly calls the remote server. Instead, it says to the MCP client: "Call the weather tool with these parameters." The client formats the request in the MCP protocol, sends it over a network connection to the remote server, and waits for a response. The response comes back to your phone, and the AI uses it to craft a reply.
This is why function calling and tools work so well with on-device AI. The local model decides what to do, and remote systems execute it—but the decision-making stays local and private.
Connecting a Remote MCP Server
Setting up an MCP connector in MyBenAI is straightforward. You provide:
- Server address: The URL or address of your MCP server (e.g., a local home server, a cloud instance you control, or a third-party MCP provider).
- Authentication (optional): API keys, OAuth tokens, or certificates if the server requires them. These are stored encrypted on your device.
- Tool allowlist: Which tools this connector can expose. If the server has 50 tools, you might enable only 3 for your use case.
- Rate limits: How many tool calls per minute, to prevent runaway requests.
Once configured, MyBenAI queries the server's schema on startup. It fetches the list of available tools and their signatures. From then on, when your AI decides it needs one of those tools, it calls the remote server with your specific request.
Tool Allowlists and Permission Controls
The allowlist is your safety layer. Not every MCP server is trustworthy, and not every tool should be available in every conversation. MyBenAI gives you per-connector control:
- Enable or disable entire connectors: Turn off a connector during a certain conversation, or disable it permanently if you no longer use it.
- Whitelist specific tools: A connector might offer 20 tools; you enable only the 3 you need. The AI can only call whitelisted tools.
- Set scope-based rules: Some tools might be restricted to certain conversation contexts. E.g., "Allow the email sender tool only if the user explicitly asks for email."
- Inspect tool calls: Before the AI sends a request to a remote server, you can review it in MyBenAI's network log, see exactly what parameters are being sent, and approve or deny it.
This prevents prompt injection attacks. Even if a malicious prompt tries to trick the AI into calling a tool, the allowlist enforces what's actually available. The AI can't call an unauthorized tool, no matter what you ask.
Real-World Examples: What You Can Build
Personal home automation: Run an MCP server on your home network (or a Raspberry Pi). MyBenAI connects to it and can ask "Turn on the bedroom lights" or "What's the current temperature?" The AI stays on your phone; control happens locally.
Database access: Self-host a PostgreSQL server or connect to a private database. Your AI can query it: "Show me sales from Q3" or "Find all customers in Portland." The query happens server-side; the results come back to your phone in a few milliseconds.
API bridging: Connect to a service that requires authentication. E.g., if you have a Stripe account, run an MCP server that wraps Stripe's API. Your AI can ask "What was my revenue last month?" The server fetches Stripe data and returns a summary. Your Stripe key never leaves your own server.
Semantic search over private documents: Run semantic search over a remote database like Postgres + pgvector from your local AI. Your queries are private; only the server sees the search vector.
Custom business logic: Some workflows are too complex for local tools. An MCP server can run a multi-step pipeline: AI asks, server processes (maybe calling 3 other APIs, doing a calculation, logging the result), server responds with the outcome. All orchestrated from your phone, without exposing your conversation context.
Performance and Latency Considerations
Remote tool calls add network latency. A local calculator returns instantly; a remote call takes time proportional to the network distance and server response time. This is the honest trade-off of MCP connectors: you gain access to rich external systems, but you pay in round-trip time.
MyBenAI mitigates this in a few ways:
- Parallel requests: If the AI needs to call multiple tools, MyBenAI sends them in parallel when possible, not serially. Multiple tool calls happen concurrently, then results are gathered.
- Connection pooling: Reusing network connections reduces handshake overhead. The first call to a server is slower; subsequent calls are faster.
- Caching tool schemas: MyBenAI caches the list of available tools, so it doesn't re-query the server every time you open a conversation.
Local MCP servers (on your home network) are significantly faster than remote servers over the internet. If you're using multiple tools in a single AI response, network round-trips can accumulate, but most users find the trade-off acceptable for the convenience and capability gain.
Security: Network Visibility and Audit Logs
Every MCP tool call appears in MyBenAI's network log. You can see:
- Which connector was called.
- Which tool was invoked.
- What parameters were sent.
- What response came back.
- Timing and success/failure status.
This transparency is critical. If an MCP server is compromised or behaves unexpectedly, you'll see it. The network log is built into MyBenAI's admin console, accessible anytime. You can review your tool usage history and spot suspicious activity. Unlike cloud AI services, where tool calls are opaque, your MCP calls are visible and auditable.
Additionally, authentication tokens (API keys, OAuth refresh tokens) are stored encrypted in MMKV (MyBenAI's secure key-value store), separate from your chat history. If you revoke a connector, its tokens are deleted. Uninstalling MyBenAI removes all connector credentials.
MCP vs Built-in Tools and REST Connectors
MyBenAI supports three levels of tool integration. Understanding the differences helps you choose the right approach:
- Built-in tools: Calculator, clock, contacts, calendar, weather, currency conversion. These live in the app; no network call. Zero latency, always available.
- REST connectors: Declarative HTTP API integrations. Define a URL, method, parameters, and parsing. Simpler than MCP but less flexible. No state, no complex logic on the server side.
- MCP connectors: Full server-side logic. The remote server can maintain state, run multi-step workflows, access databases, call other services. More powerful, more complex to set up.
Start with built-in tools. If you need to integrate an external service, try a REST connector. If a REST connector can't express what you need (e.g., a workflow that requires server-side state or complex business logic), graduate to an MCP connector.
Getting Started With MCP on Your Phone
To use MCP connectors to extend your AI with remote servers, you need:
- An MCP server (self-hosted, cloud-hosted, or a public service).
- The server's address and any authentication details.
- A recent version of MyBenAI with MCP support enabled.
Open MyBenAI settings, go to Connectors, and add a new MCP connector. Paste the server address, test the connection, review the available tools, set your allowlist, and save. The next time your AI needs one of those tools, it will call the remote server.
If you're interested in building an offline AI assistant, MCP gives you a path to connect it to the services you care about, without compromising privacy. And if you want to learn more about how tool calling works without API keys, that same architecture powers MCP integrations.
When to Use MCP, When to Skip It
MCP is powerful but adds complexity. You should use it if:
- You need to access external data (databases, APIs) that a built-in tool or REST connector can't handle.
- The integration requires complex server-side logic or multi-step workflows.
- You're self-hosting and want your AI to access your own systems without sending data to a third party.
You should skip it if:
- A built-in tool or REST connector already solves your problem.
- You're uncomfortable running or maintaining a remote server.
- Network latency is critical to your use case (MCP calls incur network round-trip time proportional to your connection and server distance).
MCP connectors unlock a new level of integration for on-device AI. By moving orchestration to your phone and keeping your conversations local, you get the power of remote systems without sacrificing privacy. Ready to extend your AI? Get MyBenAI and start building custom connectors. Learn more about what tools your AI can access, or dive deeper into how function calling and tools work.