For product and engineering teams that already operate an MCP server - and want those tools available in customer conversations.
Bring the tools exposed by your MCP server into Robofy. Paste your server configuration, verify the connection, discover available tools, and make them available to an AI Agent - without rebuilding each operation as a separate integration.
Robofy acts as the MCP client. After the connection is verified, it retrieves the tools your server exposes so the agent can look up business context or trigger supported actions during a live conversation. Your REST, GraphQL, and internal APIs can keep doing the underlying work.
MCP server integration connects an AI application to tools exposed through the Model Context Protocol. In Robofy, you add an MCP server at the project level, test the connection, and review the tools returned by the server. You can then enable that server for a specific AI Agent so it can use the available tools when they are relevant to a conversation.
Robofy acts as the MCP client for this feature. Your MCP server remains the source of the tools, schemas, data access, and permissions.
Robofy verifies the server before it is saved and shows the tools it discovers. That gives your team a clear checkpoint between adding a configuration and exposing capabilities to an agent.
Open Integrations, choose Add MCP server, and paste the command, arguments, URL, headers, or environment values required by your server. Credentials stay masked in the product surface.
Robofy validates the configuration and requests the available tool list before you save the server. Clear progress states show exactly what is happening.
Verified tool names appear as capabilities the agent can use. Enable the saved server for the AI Agent that should use it. The MCP server continues to define permissions and the operations behind them.
{ "mcpServers": { "operations": { "command": "npx", "args": ["-y", "example-mcp"] } }}→ initialize← protocolVersion: 2025-06-18→ tools/list+ 4 more tools exposed by this server
What the agent can do depends on the tools exposed by your MCP server. The customer only sees a helpful answer. Behind the scenes, Robofy chooses an available tool, sends the request, and uses the result in context.
Tool names and responses are illustrative. Available actions depend on your MCP server and permissions.
Where is order #RBF-2048?
{ "order_id": "RBF-2048" } Result received in 428msYour order left the Bengaluru hub this morning and is scheduled to arrive tomorrow by 6 PM. I can also share the tracking link.
Is the blue Pro kit available in Pune?
{ "sku": "PRO-BLU", "location": "Pune" } 12 units availableYes - 12 blue Pro kits are available in Pune right now. Would you like me to reserve one?
Create a priority ticket for my billing issue.
{ "type": "billing", "priority": "high" } Ticket RBF-991 createdDone. I created priority ticket RBF-991 for the billing team. You’ll receive an update by email.
No. Your REST, GraphQL, database, or internal services can continue to perform the underlying work. An MCP server exposes selected capabilities in a format an MCP-compatible client can discover and use. Robofy connects to that tool layer; it does not require you to replace the systems behind it.
Your existing systems
MCP server
Discovers, describes, and governs selected capabilitiestools/listtools/callRobofy AI Agent
Chooses and invokes the right tool in contextRobofy is the MCP client. It verifies STDIO or HTTP/SSE configurations, discovers tools from your server, and calls a tool only when the conversation needs it.
The Robofy interface accepts process-based STDIO configurations and remote HTTP/SSE configurations. Use the format that matches your server and verify it before saving.
Robofy tests the submitted configuration and requests the available tool list before the MCP server is saved.
Tool names and schemas come from the connected MCP server. When the server changes what it exposes, verify the connection again to refresh the tools shown in Robofy.
MCP server records are scoped to a Robofy project. A verified server can be enabled for the specific AI Agent that should use it.
Teams can mark an MCP server active or inactive and disconnect it from an agent without deleting the project connection.
Use least-privilege credentials and expose only the tools needed for the workflow. Access must also be enforced by the MCP server and the systems behind it.
Robofy agrees on protocol capabilities, retrieves the catalog with tools/list, matches a definition to user intent, and invokes the tool with tools/call only when the conversation needs it.
initializeclient: robofy-agentinitializedprotocolVersion acceptedtools/listrequest available definitionstools8 definitions receivedtools/call · get_order{ order_id: RBF-2048 }resultstatus: in_transit · eta: tomorrowThis STDIO example uses placeholder values. Remote HTTP/SSE configurations can provide a URL and headers instead. Never place real API keys in screenshots, source control, or public examples.
{
"mcpServers": {
"operations": {
"command": "npx",
"args": ["-y", "your-mcp-server-package"],
"env": { "API_KEY": "YOUR_API_KEY" }
}
}
}The MCP server determines which tools are exposed and what each tool is permitted to do. Give the connection only the access required for its intended workflow, keep secrets out of public examples and source control, and enforce authentication and authorization in the server and downstream systems.
Robofy’s platform security posture does not replace the access controls required for an individual MCP server connection. Your server still owns its tools, credentials, and data policies.
Answers about MCP server integration, tool discovery, STDIO and HTTP/SSE transports, and where MCP fits with APIs, Function Tool Calling, and webhooks.
An MCP server exposes tools and other capabilities through the Model Context Protocol so compatible AI applications can discover and use them. A tool can retrieve data, call an API, or perform another operation defined by the server.
For this integration, Robofy acts as the MCP client. It connects your AI Agent to the MCP server you configure. Your server remains the source of the tools, schemas, and permissions.
Open Integrations in your Robofy project, select Add MCP server, paste the supported configuration JSON, test the connection, review the discovered tools, save the server, and enable it for the required AI Agent.
Yes. After the connection is verified, Robofy retrieves the tool definitions exposed by that server. The results depend on the server configuration and permissions.
No. Existing services can keep performing the underlying work while the MCP server exposes selected operations as tools. Robofy connects to that tool layer; it does not require you to replace the systems behind it.
The Robofy configuration surface supports demonstrated STDIO and remote HTTP/SSE configuration forms. Use the form supported by your server and verify the connection before saving.
No. Tool names and schemas come from the verified MCP server. That is the main difference from defining individual Function Tool Calls directly in Robofy.
Yes. Use MCP for reusable tools already exposed through an MCP server, and use Function Tool Calling for a specific HTTPS API action you want to define inside Robofy.
Yes, if the MCP server exposes carefully scoped database-backed tools. The agent does not receive unrestricted database access unless your server is designed that way.
It remains saved in the project but is not available for active use until it is reactivated. You can disconnect a server from an agent without deleting the project connection.
The MCP server controls which tools it exposes and should enforce authentication, authorization, and least-privilege access for every operation. Robofy only decides which saved server is enabled for an AI Agent.
MCP makes tools available for the agent to invoke during a conversation. Webhooks notify an external endpoint when configured conversation events occur, such as lead capture, human handoff, or session end.
Connect a server, verify its tools, and make the right capabilities available to your Robofy AI Agent.