Remote MCP Server Integration

Interfaze ships a hosted Model Context Protocol server that exposes every Interfaze capability as MCP tools. Point any MCP-compatible client Cursor, Claude, VS Code, or your own agent at the server and it can search the web, scrape pages, run OCR, transcribe audio, detect objects, translate text, and forecast time series.

Connection details

Every request must include your Interfaze API key as a bearer token: Authorization: Bearer <your-api-key>

Get your API key from the dashboard.

Available tools

Prefer the task-specific tools when a request maps directly to one of them, and reach for ask_interfaze for multi-step or open-ended work.

Connecting your client

Cursor

Add the server to .cursor/mcp.json in your project (or the global ~/.cursor/mcp.json):

{
  "mcpServers": {
    "interfaze": {
      "url": "https://api.interfaze.ai/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}

VS Code

Add the server to .vscode/mcp.json:

{
  "servers": {
    "interfaze": {
      "type": "http",
      "url": "https://api.interfaze.ai/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}

Claude Code

Register the server with the CLI:

claude mcp add --transport http interfaze https://api.interfaze.ai/mcp \
  --header "Authorization: Bearer <your-api-key>"

Claude Desktop & stdio-only clients

Some clients only speak the local stdio transport. Bridge to the remote server with mcp-remote:

{
  "mcpServers": {
    "interfaze": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.interfaze.ai/mcp", "--header", "Authorization: Bearer <your-api-key>"]
    }
  }
}

Using the MCP SDK

Connect programmatically with the official MCP SDK and the Streamable HTTP transport.

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://api.interfaze.ai/mcp"),
  {
    requestInit: {
      headers: { Authorization: `Bearer ${process.env.INTERFAZE_API_KEY}` },
    },
  }
);

const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
console.log(tools.map((t) => t.name));

const result = await client.callTool({
  name: "web_search",
  arguments: { prompt: "What are the latest updates to the OpenAI API?" },
});
console.log(result.content);

Using with the Vercel AI SDK

The Vercel AI SDK can connect to the server and convert its tools into AI SDK tools automatically. Your main model then decides which Interfaze tool to call during the agent loop.

Install the dependencies:

npm install ai @ai-sdk/mcp @ai-sdk/openai

Connect over the recommended HTTP transport, pass your API key as a header, and hand the discovered tools to generateText:

import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const mcpClient = await createMCPClient({
  transport: {
    type: "http",
    url: "https://api.interfaze.ai/mcp",
    headers: {
      Authorization: `Bearer ${process.env.INTERFAZE_API_KEY}`,
    },
  },
});

try {
  const tools = await mcpClient.tools();

  const { text } = await generateText({
    model: openai("gpt-5"),
    tools,
    stopWhen: stepCountIs(10),
    prompt: "Search the web for the latest updates to the OpenAI API and summarize the top results.",
  });

  console.log(text);
} finally {
  await mcpClient.close();
}

When streaming with streamText, close the client in the onEnd callback instead of a finally block so the connection stays open until the response finishes.