Zero-config exposure
Every enabled contract is already an MCP tool. No manual registration.
Every API contract you build on VectorFlowApp becomes a Model Context Protocol tool automatically. Claude, Cursor, Cline, and any MCP-compatible client can list and call your APIs through one endpoint — no extra code, no proprietary bridges.
The Model Context Protocol (MCP) is an open standard that lets large-language-model clients discover and call external tools in a uniform way. Instead of writing bespoke function-calling adapters for every provider, you expose a single MCP endpoint; every MCP-aware client can find, inspect, and invoke what you publish.
VectorFlowApp ships an MCP server as part of the control plane. It automatically enumerates the API contracts in your organization and advertises each one as a callable tool — with input schema, operation metadata, and secure proxying back to your gateway. The LLM never talks to your gateway directly; it talks to MCP, and MCP routes to the gateway using the same policies you already configured.
Every enabled contract is already an MCP tool. No manual registration.
JWT, API keys, rate limits, and schema validation run before the tool call lands.
Claude Desktop, Cursor, Cline, and any MCP client — the same URL works for all.
Three things happen in order: the client handshakes, enumerates your API contracts as tools, and invokes one. The gateway keeps owning auth, rate limits, and runtime — MCP is a thin control surface on top.
initializeThe MCP client POSTs a JSON-RPC initialize call. VectorFlowApp responds with protocolVersion 2025-06-18 and a capabilities block advertising tool support.
tools/listThe client requests the tool catalog. VectorFlowApp enumerates every enabled ApiContract in the org, converting each to an MCP tool with a stable name, description, and input schema derived from the contract's method and payload shape.
tools/callThe client invokes a named tool with arguments. VectorFlowApp resolves the tool back to its contract, assembles an HTTP request, forwards it through the gateway pipeline (policies first), and returns the response to the client as structured content.
Already running the gateway with at least one published API contract? You already have an MCP server. Here's how to point Claude Desktop or any MCP client at it.
curl -X POST 'http://localhost:8080/management/api/v1/mcp?org=YOUR_ORG_ID' \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}' | jq .Every enabled contract in your org is listed. Each tool's name maps to a contract; the inputSchema describes what the LLM needs to pass in.
curl -X POST 'http://localhost:8080/management/api/v1/mcp?org=YOUR_ORG_ID' \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' | jq '.result.tools'curl -X POST 'http://localhost:8080/management/api/v1/mcp?org=YOUR_ORG_ID' \
-H "Content-Type: application/json" \
-d '{
"jsonrpc":"2.0","id":3,"method":"tools/call",
"params":{
"name":"DEMO__post_customers",
"arguments":{"customer_name":"Ada","phone":"+1-555-0100"}
}
}'Add the server to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"vectorflow": {
"url": "https://your-gateway.example.com/management/api/v1/mcp?org=YOUR_ORG_ID"
}
}
}Restart Claude. Your API contracts appear in the tool picker.
The MCP server is a thin surface. All enforcement happens on the gateway — where you already set it up.
Every MCP request carries an org parameter. Only contracts owned by that organization are exposed. No cross-tenant leakage.
A tool call is just an HTTP call internally. JWT auth, API keys, rate limits, and schema validation all execute before any connector step.
Connector credentials resolved via Vault, AWS Secrets Manager, GCP Secret Manager, or Azure Key Vault — never passed through MCP.
Every MCP-initiated call lands in the same gateway metrics stack. Trace IDs, request durations, and errors are visible in Prometheus and Grafana.
Give Claude or an in-house agent the ability to read customers, open support tickets, and fetch inventory — through your existing API contracts, with your policies.
Chain MCP tool calls inside a VectorFlowApp flow. The LLM decides which tool to call; the gateway executes it; the response feeds the next step.
Expose a curated subset of contracts under a partner-scoped MCP endpoint. The customer's AI agent only sees the tools you permit.
Cursor and other coding tools can read schemas, test endpoints, and generate client code against your gateway — no local SDK generation step.
No. Every enabled contract in your organization is automatically listed by tools/list. You disable exposure by disabling the contract.
Any client that speaks protocol version 2025-06-18. Confirmed: Claude Desktop, Cursor, Cline. Any client that correctly implements the three methods above will work.
Via contract-level flags and the org scope. Per-partner MCP endpoints are planned; the current MVP exposes all enabled contracts in the specified org.
Unchanged. A tool call runs through the identical gateway pipeline as any HTTP request. Your JWT verification, API key rate limits, and schema validation apply exactly as they already do.
The MCP endpoint ships enabled by default. We recommend running it behind an authenticated reverse proxy for production (the gateway's /management surface is admin-only by design).
MCP is client-agnostic — Claude, Cursor, and any future MCP-aware runtime use the same server. OpenAI function calling is a provider-specific protocol you'd implement per-client. MCP's tool list is also discoverable at runtime; function-call schemas are static per request.
Tell us about the systems you connect and the automations you need. We will walk through what VectorFlowApp ships today and how it fits your stack.