Remote MCP server

Overview

The remote MCP server is hosted by Chift at https://mcp.chift.eu/mcp. There is nothing to install: you point an MCP client at that URL and authorize through the Chift OAuth flow. Each authorization is tied to a single consumer, and the tools an agent can see are limited to the scopes granted during authorization. This makes the remote server well suited to productized, agentic use cases where an assistant acts on behalf of one of your customers with a deliberately bounded set of tools.

Prerequisites

A Chift account with at least one consumer that has active integrations.
An MCP-compatible client (Claude Desktop, Cursor, VS Code, Claude Code, or any framework that supports MCP).

DataLayer

If the consumer you authorized is connected to the DataLayer, the server automatically uses it as the source of truth for read operations. Your agent’s queries are served from Chift’s synced data store rather than hitting the source system live on every request, which keeps responses fast and consistent. No configuration is required. When a consumer is connected to the DataLayer, reads route through it automatically.

Authentication

OAuth 2.0 (recommended)
Legacy token

The remote server supports OAuth 2.0 with Dynamic Client Registration (RFC 7591). Point your MCP client at https://mcp.chift.eu/mcp and it handles client registration, the login redirect, and credential storage for you.

Add the server

Point your MCP client at https://mcp.chift.eu/mcp (see Connecting your client). On first use, the client opens a browser on Chift.

Authorize

Chift OAuth consent screen: choosing a consumer and the scopes to grant to an MCP client

Start building

The client stores the connection and the agent can call the granted tools. Reconnecting reuses the saved credentials, so you will not be asked to authorize again.

Scopes

Scopes decide which tools an agent sees. They are defined at two levels:

The set a builder makes available for their integration, configured on the MCP settings page.
The subset a user grants during authorization.

An agent only ever sees tools for the scopes granted at authorization, and never more than the builder allows. Each scope is a vertical (such as accounting) that you can narrow to read only or to specific entities (for example, only invoices and VAT codes).

Scope selection for a vertical, expanded to show per-entity read and write toggles

This method is maintained for backward compatibility. We recommend the OAuth 2.0 flow for new integrations.

Request an access token with a POST to https://api.chift.eu/mcp-token, then pass it to your client as a bearer token.

curl -X POST 'https://api.chift.eu/mcp-token' \
  -H 'Content-Type: application/json' \
  -d '{
    "clientId": "your_client_id",
    "clientSecret": "your_client_secret",
    "accountId": "your_account_id",
    "consumerId": "your_consumer_id"
  }'

Response:

{
  "access_token": "your_mcp_access_token",
  "token_type": "bearer",
  "expires_in": 1800,
  "expires_on": 1234567890
}

clientId

string

required

Your Chift client ID

clientSecret

string

required

Your Chift client secret

accountId

string

required

Your Chift account ID (UUID format)

consumerId

string

required

Your consumer ID (UUID format)

envId

string

Optional environment ID (UUID format)

marketplaceId

string

Optional marketplace ID (UUID format)

Add the token to your client with an Authorization: Bearer <your_mcp_access_token> header (see the examples in Connecting your client).

Connecting your client

Point your client at https://mcp.chift.eu/mcp. Each client sets up the connection and authentication slightly differently, so follow the tab for the one you use.

IDE configuration

Claude Desktop
Cursor
VS Code
Claude Code

Claude Desktop cannot connect to a remote server directly, so it uses the mcp-remote bridge. Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "chift-remote": {
      "command": "/path/to/npx",
      "args": [
        "mcp-remote",
        "https://mcp.chift.eu/mcp",
        "--transport",
        "http-only",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer <your_mcp_access_token>"
      }
    }
  }
}

The example above authenticates with a legacy token passed through AUTH_HEADER. To use OAuth instead, remove the --header argument and the AUTH_HEADER env var: mcp-remote then opens a browser for you to log in and authorize on first use.

Install in CursorClick install to open Cursor and add the Chift MCP automatically, or add the following to your ~/.cursor/mcp.json file. See the Cursor documentation to learn more.

{
  "mcpServers": {
    "chift": {
      "url": "https://mcp.chift.eu/mcp"
    }
  }
}

Cursor connects to the hosted server directly and runs the OAuth flow in your browser on first use. To use a legacy token instead, add a headers object with Authorization: Bearer <your_mcp_access_token>.

Install in VS CodeClick install to open VS Code and add the Chift MCP automatically, or add the following to your .vscode/mcp.json file. See the VS Code documentation to learn more.

{
  "servers": {
    "chift": {
      "type": "http",
      "url": "https://mcp.chift.eu/mcp"
    }
  }
}

VS Code connects to the hosted server directly and runs the OAuth flow in your browser on first use. To use a legacy token instead, add a headers object with Authorization: Bearer <your_mcp_access_token>.

Claude Code connects to the hosted server directly. Run the following command, and it runs the OAuth flow in your browser on first use. See the Claude Code documentation to learn more.

claude mcp add --transport http chift https://mcp.chift.eu/mcp

To use a legacy token instead, add --header "Authorization: Bearer <your_mcp_access_token>" to the command.

Using with AI frameworks

You can integrate the remote server with popular AI frameworks to build applications on top of Chift’s Unified API.

AI SDK (Vercel)
Pydantic AI
LangChain Python
LangChain TypeScript

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

async function getTools() {
  const response = await fetch("https://api.chift.eu/mcp-token", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      clientId: "your_client_id",
      clientSecret: "your_client_secret",
      accountId: "your_account_id",
      consumerId: "your_consumer_id",
    }),
  });

  const { access_token } = await response.json();

  const mcpClient = createMCPClient({
    transport: {
      type: "http",
      url: "https://mcp.chift.eu/mcp",
      headers: {
        Authorization: `Bearer ${access_token}`,
      },
    },
  });

  return await mcpClient.listTools();
}

const result = await generateText({
  model: openai("gpt-4"),
  tools: await getTools(),
  prompt: "List all accounting connections for my consumer",
});

import httpx
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStreamableHTTP

async def get_tools():
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.chift.eu/mcp-token",
            json={
                "clientId": "your_client_id",
                "clientSecret": "your_client_secret",
                "accountId": "your_account_id",
                "consumerId": "your_consumer_id",
            },
        )
        data = response.json()
        access_token = data["access_token"]

    return MCPServerStreamableHTTP(
        "https://mcp.chift.eu/mcp",
        headers={"Authorization": f"Bearer {access_token}"}
    )

async def main():
    tools = await get_tools()
    agent = Agent("openai:gpt-4", toolsets=[tools])
    result = await agent.run("Give me my orders of yesterday")
    print(result.output)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

import httpx
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

async def get_tools():
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "https://api.chift.eu/mcp-token",
            json={
                "clientId": "your_client_id",
                "clientSecret": "your_client_secret",
                "accountId": "your_account_id",
                "consumerId": "your_consumer_id",
            },
        )
        data = response.json()
        access_token = data["access_token"]

    client = MultiServerMCPClient({
        "chift": {
            "url": "https://mcp.chift.eu/mcp",
            "transport": "streamable_http",
            "headers": {
                "Authorization": f"Bearer {access_token}"
            }
        }
    })
    tools = await client.get_tools()
    return tools

async def main():
    tools = await get_tools()

    llm = ChatOpenAI(model="gpt-4")
    agent = create_agent({
        "model": llm,
        "tools": tools,
    })

    result = agent.invoke({
        "messages": [("user", "List all accounting connections")]
    })
    print(result)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { ChatOpenAI } from "@langchain/openai";
import { createAgent } from "langchain/agents";

async function getTools() {
  const response = await fetch("https://api.chift.eu/mcp-token", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      clientId: "your_client_id",
      clientSecret: "your_client_secret",
      accountId: "your_account_id",
      consumerId: "your_consumer_id",
    }),
  });

  const { access_token } = await response.json();

  const client = new MultiServerMCPClient({
    chift: {
      transport: "streamable_http",
      url: "https://mcp.chift.eu/mcp",
      headers: {
        Authorization: `Bearer ${access_token}`,
      },
    },
  });

  return await client.getTools();
}

async function main() {
  const tools = await getTools();

  const llm = new ChatOpenAI({
    model: "gpt-4",
  });

  const agent = createAgent({
    model: llm,
    tools: tools,
  });

  const result = await agent.invoke({
    messages: [["user", "List all accounting connections"]],
  });
  console.log(result);
}

main();

The AI framework examples use the legacy token method for simplicity. For production applications, we recommend implementing OAuth 2.0.

Tools and scopes

The remote server’s tools mirror the Unified API one-to-one across accounting, banking, ecommerce, invoicing, payment, PMS, and POS. The tools available in a session depend on the scopes granted during authorization. You only see tools for the verticals and operations you were authorized for, and read-only scopes expose read operations only. See Scopes for how they are defined.

​Overview

​Prerequisites

​DataLayer

​Authentication

​Scopes

​Connecting your client

​IDE configuration

​Using with AI frameworks

​Tools and scopes

Overview

Prerequisites

DataLayer

Authentication

Scopes

Connecting your client

IDE configuration

Using with AI frameworks

Tools and scopes