Local MCP server

Overview

The local MCP server is an open-source Python package you run on your own machine over stdio. You authenticate once with your Chift API credentials, and unlike the remote server it can work across all of your consumers rather than a single one. It is built for builders: if you have a Chift account with several consumers and you want an assistant that helps you configure Chift and explore the Unified API across them, the local server is the right tool. It also offers an optional documentation search tool that brings the entire Chift documentation into your coding assistant’s context. The source code is available on GitHub.

Prerequisites

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

More detail on prerequisites is available in the project README.

Installation

The server runs with uvx, which fetches and launches the package in one step:

uvx chift-mcp-server@latest

You normally do not run this by hand. Your MCP client launches it for you using the configuration in Connecting your client. Set your credentials as environment variables first (see Configuration).

Configuration

The server reads its configuration from environment variables (prefixed with CHIFT_), which you can set in your MCP client configuration or a local .env file.

Variable	Description	Required
`CHIFT_CLIENT_ID`	Your Chift client ID	Yes
`CHIFT_CLIENT_SECRET`	Your Chift client secret	Yes
`CHIFT_ACCOUNT_ID`	Your Chift account ID	Yes
`CHIFT_CONSUMER_ID`	Restrict the server to a single consumer. Leave unset to work across all of your consumers	No
`CHIFT_SEARCH`	Set to `true` to enable the documentation search tool (defaults to `false`)	No
`CHIFT_FUNCTION_CONFIG`	Restrict which operations are available per domain (see Function configuration)	No

Leaving CHIFT_CONSUMER_ID unset is what makes the local server useful to builders: the assistant can discover and work across every consumer on your account. Set it when you want to pin a session to one consumer.

Connecting your client

IDE configuration

Claude Desktop
Cursor
VS Code
Claude Code

Add the following to your claude_desktop_config.json:

{
  "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
      }
    }
  }
}

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
      }
    }
  }
}

Add the following to your .vscode/mcp.json file:

{
  "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
      }
    }
  }
}

Add the server, then set your environment variables:

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

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

Using with AI frameworks

When running locally you integrate the server over stdio transport.

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

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

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

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

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

main();

Function configuration

By default, all operations are enabled for every domain:

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

Set the CHIFT_FUNCTION_CONFIG environment variable to restrict which operations are exposed per domain, for example to give an assistant read-only access. More detail is available in the project README.

Function configuration is specific to the local server. The remote server uses OAuth scopes to control which operations are available.

Documentation search

The local server can expose a SearchChift tool that searches the entire Chift documentation like a vector database: pass a query and retrieve the documentation passages that match semantically. It brings Chift documentation directly into your coding assistant’s context, which helps it integrate Chift faster. The tool is off by default. Enable it by setting:

CHIFT_SEARCH=true

// Search documentation via MCP
const result = await mcp.call_tool('SearchChift', {
  query: 'How to authenticate webhook requests?'
});

​Overview

​Prerequisites

​Installation

​Configuration

​Connecting your client

​IDE configuration

​Using with AI frameworks

​Function configuration

​Documentation search

Overview

Prerequisites

Installation

Configuration

Connecting your client

IDE configuration

Using with AI frameworks

Function configuration

Documentation search