Model Context Protocol (MCP)

Overview

The Chift Model Context Protocol (MCP) defines a set of tools you can use to build AI Agents that can interact with the different integrations offered by Chift and search in our documentation through one MCP server. It exposes the Chift Unified API to any LLM provider supporting the MCP protocol like Claude, Cursor or Windsurf. Chift MCP server can be found here.

Getting Started

You can use the Chift MCP server in two ways:

Remote Server (Recommended) - Connect directly to our hosted MCP server
Local Installation - Install and run the server locally

Choose the option that best fits your needs:

Remote Server (Recommended)

The remote server is the easiest way to get started with Chift MCP. No local installation required!

Prerequisites

A Chift account with client credentials (client ID, client secret, account ID, and consumer ID)

Getting an Access Token

To use the remote server, you first need to obtain an access token by making a POST request to https://api.chift.eu/mcp-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
}

Required Parameters

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)

Using with AI Frameworks

You can integrate the Chift MCP server with popular AI frameworks to build intelligent applications that interact with Chift’s Unified API.

AI SDK (Vercel)
Pydantic AI
LangChain Python
LangChain TypeScript

Connect to the Chift MCP server using the Vercel AI SDK:

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",
      headers: {
        Authorization: `Bearer ${access_token}`,
      },
    },
  });

  return await mcpClient.listTools();
}

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

Connect to the Chift MCP server using Pydantic AI:

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",
        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())

Connect to the Chift MCP server using LangChain Python:

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",
            "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,
    })

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

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

Connect to the Chift MCP server using LangChain TypeScript:

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",
      headers: {
        Authorization: `Bearer ${access_token}`,
      },
    },
  });

  const tools = await client.getTools();
}

async function main() {
  const tools = await client.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();

IDE Configuration

Claude Desktop
Cursor
VS Code
Claude Code

Configure Claude for Desktop to use the remote MCP server:

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

Install in CursorTo open Cursor and automatically add the Chift MCP, click install. Alternatively, add the following to your ~/.cursor/mcp.json file. To learn more, see the Cursor documentation.

{
  "mcpServers": {
    "chift": {
      "url": "https://mcp.chift.eu",
      "headers": {
        "Authorization": "Bearer <your_mcp_access_token>"
      }
    }
  }
}

Install in VS CodeTo open VS Code and automatically add the Chift MCP, click install. Alternatively, add the following to your .vscode/mcp.json file in your workspace. To learn more, see the VS Code documentation.

{
  "servers": {
    "chift": {
      "type": "http",
      "url": "https://mcp.chift.eu",
      "headers": {
        "Authorization": "Bearer <your_mcp_access_token>"
      }
    }
  }
}

To add MCP to Claude Code, run the following command. To learn more, see the Claude Code documentation.

claude mcp add --transport http chift https://mcp.chift.eu/ --header "Authorization: Bearer <your_mcp_access_token>"

Replace <your_mcp_access_token> with the token received from the /mcp-token endpoint.

Setup Steps

Get your MCP access token using the API call above
Choose your preferred IDE from the tabs above
Either use the one-click install link or manually add the configuration
Replace <your_mcp_access_token> with your actual token
Restart your IDE/application
You should see the Chift tools available in the chat interface

The remote server setup is complete! You can now use Chift MCP tools in your chosen IDE without any local dependencies.

Local Installation

You can also run the MCP server locally in a stdio environment. Local installation is ideal if you want better AI support during integration of the Chift API. Running the MCP server locally allows you to:

Choice between limiting the MCP server to a specific consumer or allowing access to all
Search and reference the entire Chift Documentation directly from your IDE for improved AI context when
Customize your setup for specific workflows

Prerequisites

A Chift account with client credentials (client ID, client secret, account ID, and consumer ID)
Python 3.11 or higher
uv package manager

More information about local installation can be found here

Installation Steps

Install the required dependencies (Python 3.11+ and uv)
Install the Chift MCP server package
Configure your environment variables
Set up your client configuration

Using with AI Frameworks (Local Installation)

When running the MCP server locally, you can integrate it with popular AI frameworks using stdio transport. Local installation enables documentation search and provides better control over your setup.

AI SDK (Vercel)
Pydantic AI
LangChain Python
LangChain TypeScript

For local installation, use stdio transport:

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

async function getTools() {
  const mcpClient = createMCPClient({
    command: "uvx",
    args: ["chift-mcp-server@latest"],
    env: {
      CHIFT_CLIENT_SECRET: process.env.CHIFT_CLIENT_SECRET,
      CHIFT_CLIENT_ID: process.env.CHIFT_CLIENT_ID,
      CHIFT_ACCOUNT_ID: process.env.CHIFT_ACCOUNT_ID,
      CHIFT_CONSUMER_ID: process.env.CHIFT_CONSUMER_ID,
      CHIFT_SEARCH: "true",
    },
  });

  return await mcpClient.listTools();
}

const result = await generateText({
  model: openai("gpt-4"),
  tools: await getTools(),
  prompt: "Search the documentation for webhook authentication",
});

For local installation with stdio transport:

from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio

async def main():
    tools = MCPServerStdio(
        command="uvx",
        args=["chift-mcp-server@latest"],
        env={
            "CHIFT_CLIENT_SECRET": "your_client_secret",
            "CHIFT_CLIENT_ID": "your_client_id",
            "CHIFT_ACCOUNT_ID": "your_account_id",
            "CHIFT_CONSUMER_ID": "your_consumer_id",
            "CHIFT_SEARCH": "true",
        }
    )
    agent = Agent("openai:gpt-4", toolsets=[tools])
    result = await agent.run("Search documentation for webhook setup")
    print(result.output)

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

For local installation with stdio transport:

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

async def get_tools():
    client = MultiServerMCPClient({
        "chift": {
            "command": "uvx",
            "args": ["chift-mcp-server@latest"],
            "transport": "stdio",
            "env": {
                "CHIFT_CLIENT_SECRET": os.getenv("CHIFT_CLIENT_SECRET"),
                "CHIFT_CLIENT_ID": os.getenv("CHIFT_CLIENT_ID"),
                "CHIFT_ACCOUNT_ID": os.getenv("CHIFT_ACCOUNT_ID"),
                "CHIFT_CONSUMER_ID": os.getenv("CHIFT_CONSUMER_ID"),
                "CHIFT_SEARCH": "true",
            }
        }
    })
    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", "Search documentation for webhook setup")]
    })
    print(result)

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

For local installation with stdio transport:

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

async function getTools() {
  const client = new MultiServerMCPClient({
    chift: {
      transport: "stdio",
      command: "uvx",
      args: ["chift-mcp-server@latest"],
      env: {
        CHIFT_CLIENT_SECRET: process.env.CHIFT_CLIENT_SECRET!,
        CHIFT_CLIENT_ID: process.env.CHIFT_CLIENT_ID!,
        CHIFT_ACCOUNT_ID: process.env.CHIFT_ACCOUNT_ID!,
        CHIFT_CONSUMER_ID: process.env.CHIFT_CONSUMER_ID!,
        CHIFT_SEARCH: "true",
      },
    },
  });

  const tools = await client.getTools();
  return tools;
}

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", "Search documentation for webhook authentication"]],
  });
  console.log(result);
}

main();

For local installations, you can enable documentation search by setting CHIFT_SEARCH=true in your environment variables. This allows the MCP server to search and reference the entire Chift Documentation directly from your IDE.

IDE Configuration

Claude Desktop
Cursor
VS Code
Claude Code

This is an example configuration for Claude Desktop when using local installation:

{
  "mcpServers": {
    "chift": {
      "command": "/path/to/uvx",
      "args": ["chift-mcp-server@latest"],
      "env": {
        "CHIFT_CLIENT_SECRET": "your_client_secret",
        "CHIFT_CLIENT_ID": "your_client_id",
        "CHIFT_ACCOUNT_ID": "your_account_id",
        "CHIFT_CONSUMER_ID": "your_consumer_id", // Optional
        "CHIFT_SEARCH": true // Optional, defaults to false
      }
    }
  }
}

For local installation with Cursor, add the following to your ~/.cursor/mcp.json file:

{
  "mcpServers": {
    "chift": {
      "command": "/path/to/uvx",
      "args": ["chift-mcp-server@latest"],
      "env": {
        "CHIFT_CLIENT_SECRET": "your_client_secret",
        "CHIFT_CLIENT_ID": "your_client_id",
        "CHIFT_ACCOUNT_ID": "your_account_id",
        "CHIFT_CONSUMER_ID": "your_consumer_id", // Optional
        "CHIFT_SEARCH": true // Optional, defaults to false
      }
    }
  }
}

For local installation with VS Code, add the following to your .vscode/mcp.json file in your workspace:

{
  "servers": {
    "chift": {
      "type": "stdio",
      "command": "/path/to/uvx",
      "args": ["chift-mcp-server@latest"],
      "env": {
        "CHIFT_CLIENT_SECRET": "your_client_secret",
        "CHIFT_CLIENT_ID": "your_client_id",
        "CHIFT_ACCOUNT_ID": "your_account_id",
        "CHIFT_CONSUMER_ID": "your_consumer_id", // Optional
        "CHIFT_SEARCH": true // Optional, defaults to false
      }
    }
  }
}

For local installation with Claude Code, first ensure you have the MCP server installed locally, then run:

claude mcp add --transport stdio chift /path/to/uvx chift-mcp-server@latest

Then set your environment variables:

export CHIFT_CLIENT_SECRET="your_client_secret"
export CHIFT_CLIENT_ID="your_client_id"
export CHIFT_ACCOUNT_ID="your_account_id"
export CHIFT_CONSUMER_ID="your_consumer_id" // Optional
export CHIFT_SEARCH=true // Optional, defaults to false

Setup Steps

Install Python 3.11+ and uv on your system
Install the Chift MCP server: uvx chift-mcp-server@latest
Set up your environment variables (see below)
Choose your preferred IDE from the tabs above and add the configuration
Replace the credential placeholders with your actual values
Restart your IDE/application
You should see the Chift tools available in the chat interface

Environment Variables for Local Installation

The following environment variables are required for local installation:

CHIFT_CLIENT_SECRET=your_client_secret
CHIFT_CLIENT_ID=your_client_id
CHIFT_ACCOUNT_ID=your_account_id
CHIFT_CONSUMER_ID=your_consumer_id  # Optional
CHIFT_SEARCH=true # Optional, defaults to false

Local installation is complete! You now have full control over your MCP server instance and can use Chift MCP tools in your chosen IDE.

Other LLM Providers

The Chift MCP server works with any LLM provider that supports the MCP protocol, not just Claude Desktop. We have elaborated on several examples (PydanticAI, Copilot, …) here

Available Tools

The Chift MCP Server dynamically generates tools based on the Chift OpenAPI specification. These tools provide access to various Chift API endpoints and include operations for:

Retrieving financial data
Managing your financial connections
Creating new financial records (invoices, payments, etc.)
Updating existing records
And much more…

All our endpoints documented in our API reference can be accessed through the Chift MCP server.

Advanced Configuration

Function Configuration (Local Installation Only)

For local installations, you can customize which operations are available for each domain. By default, all operations are enabled for all domains:

{
  "accounting": ["get", "create", "update", "add"],
  "commerce": ["get", "create", "update", "add"],
  "invoicing": ["get", "create", "update", "add"],
  "payment": ["get", "create", "update", "add"],
  "pms": ["get", "create", "update", "add"],
  "pos": ["get", "create", "update", "add"]
}

This can be customized using the CHIFT_FUNCTION_CONFIG environment variable. More details can be found here.

Function configuration is only available for local installations. The remote server provides access to all available operations.

AI

​Overview

​Getting Started

​Remote Server (Recommended)

​Prerequisites

​Getting an Access Token

​Required Parameters

​Using with AI Frameworks

​IDE Configuration

​Setup Steps

​Local Installation

​Prerequisites

​Installation Steps

​Using with AI Frameworks (Local Installation)

​IDE Configuration

​Setup Steps

​Environment Variables for Local Installation

​Other LLM Providers

​Available Tools

​Advanced Configuration

​Function Configuration (Local Installation Only)

Overview

Getting Started

Remote Server (Recommended)

Prerequisites

Getting an Access Token

Required Parameters

Using with AI Frameworks

IDE Configuration

Setup Steps

Local Installation

Prerequisites

Installation Steps

Using with AI Frameworks (Local Installation)

IDE Configuration

Setup Steps

Environment Variables for Local Installation

Other LLM Providers

Available Tools

Advanced Configuration

Function Configuration (Local Installation Only)