HUMAN THEORY APPS

Integrations

Connect arifOS MCP to your preferred AI client. Select your integration below for step-by-step configuration.

Claude Desktop

Add arifOS MCP to Claude Desktop by editing your claude_desktop_config.json:

macOS

bash
# Open the config file
code ~/Library/Application\ Support/Claude/claude_desktop_config.json

Windows

bash
# Open the config file
code %APPDATA%\Claude\claude_desktop_config.json

Configuration

json
{
  "mcpServers": {
    "arifosmcp": {
      "command": "python",
      "args": ["-m", "arifosmcp"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

Docker variant

json
{
  "mcpServers": {
    "arifosmcp": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "BRAVE_API_KEY=your_key_here",
        "ghcr.io/ariffazil/arifosmcp:latest"
      ]
    }
  }
}

Restart Claude Desktop after saving. The arifOS MCP tools will appear in the tools panel.

Cursor

Add arifOS MCP to Cursor via the MCP settings:

  1. Open Cursor Settings → Features → MCP Servers
  2. Click "Add new MCP Server"
  3. Use the following configuration:
json
{
  "mcpServers": {
    "arifosmcp": {
      "command": "python",
      "args": ["-m", "arifosmcp"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

Alternatively, create a .cursor/mcp.json file in your project root:

json
{
  "mcpServers": {
    "arifosmcp": {
      "command": "python",
      "args": ["-m", "arifosmcp"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

VS Code

For VS Code with Copilot Chat or other MCP-compatible extensions:

json — .vscode/mcp.json
{
  "servers": {
    "arifosmcp": {
      "type": "stdio",
      "command": "python",
      "args": ["-m", "arifosmcp"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

Or add to your VS Code settings.json:

json
{
  "mcp.servers": {
    "arifosmcp": {
      "type": "stdio",
      "command": "python",
      "args": ["-m", "arifosmcp"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

ChatGPT

Connect arifOS MCP to ChatGPT using the HTTP transport and the ChatGPT Actions configuration:

  1. First, start the arifOS MCP server in HTTP mode:
bash
arifosmcp serve --transport http --port 8080 --host 0.0.0.0
  1. In ChatGPT, go to Settings → Actions → Create new action
  2. Set the API endpoint to your server URL
  3. Import the OpenAPI schema from /openapi.json
Note
ChatGPT integration requires the HTTP transport mode and a publicly accessible server URL. Consider using a reverse proxy with TLS for production.

Kimi

Connect arifOS MCP to Kimi (Moonshot AI) using the MCP plugin system:

  1. Open Kimi's plugin settings
  2. Select "Add Custom MCP Server"
  3. Configure the STDIO connection:
json
{
  "name": "arifosmcp",
  "transport": "stdio",
  "command": "python",
  "args": ["-m", "arifosmcp"],
  "env": {
    "BRAVE_API_KEY": "your_brave_api_key_here"
  }
}

Python SDK

Use the MCP Python SDK to connect programmatically:

bash
pip install mcp arifosmcp
python
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server = StdioServerParameters(
        command="python",
        args=["-m", "arifosmcp"],
        env={"BRAVE_API_KEY": "your_key"}
    )

    async with stdio_client(server) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            print(f"Available tools: {[t.name for t in tools.tools]}")

            # Call reality_compass
            result = await session.call_tool(
                "reality_compass",
                {"input": "quantum computing 2026", "mode": "search"}
            )
            print(result.content[0].text)

            # Call arifOS_kernel
            result = await session.call_tool(
                "arifOS_kernel",
                {
                    "query": "Explain quantum entanglement",
                    "risk_tier": "low",
                    "use_critique": True
                }
            )
            print(result.content[0].text)

asyncio.run(main())

HTTP Client

python
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    async with streamablehttp_client("http://localhost:8080/mcp") as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("check_vital", {})
            print(result.content[0].text)

asyncio.run(main())

TypeScript SDK

Use the MCP TypeScript SDK:

bash
npm install @modelcontextprotocol/sdk
json
// TypeScript example using MCP SDK
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "python",
  args: ["-m", "arifosmcp"],
  env: { BRAVE_API_KEY: "your_key" }
});

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

await client.connect(transport);

// List tools
const tools = await client.listTools();
console.log("Tools:", tools.tools.map(t => t.name));

// Call reality_compass
const result = await client.callTool({
  name: "reality_compass",
  arguments: {
    input: "arifOS MCP documentation",
    mode: "search"
  }
});

console.log(result.content);

curl / HTTP

Interact with arifOS MCP directly via HTTP (requires HTTP transport mode):

Start the server

bash
arifosmcp serve --transport http --port 8080

Check system health

bash
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "check_vital",
      "arguments": {}
    }
  }'

Search with reality_compass

bash
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "reality_compass",
      "arguments": {
        "input": "quantum computing breakthroughs 2026",
        "mode": "search",
        "fetch_top_k": 2
      }
    }
  }'

Run the governance kernel

bash
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "arifOS_kernel",
      "arguments": {
        "query": "Is this deployment safe?",
        "risk_tier": "high",
        "use_critique": true,
        "requested_persona": "auditor"
      }
    }
  }'

List available tools

bash
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/list",
    "params": {}
  }'