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

2. In ChatGPT, go to Settings → Actions → Create new action
3. Set the API endpoint to your server URL
4. 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": {}
      }'