> ## Documentation Index
> Fetch the complete documentation index at: https://docs.walletsuite.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Install Guides

> Connect any agent framework or IDE host to the hosted WalletSuite MCP endpoint over HTTP with a bearer token.

Every framework and host connects to the same hosted endpoint, `https://mcp.walletsuite.io`, over HTTP — authenticating with a short-lived `Authorization: Bearer <token>`. There is nothing to install.

<Info>
  **Prerequisite** — a provisioned agent key. Your server authorizes the agent with it and injects a short-lived token as the `Authorization` header; the raw key never reaches the model or the MCP client. See [Connect your agent](/ai-agents/token-exchange).
</Info>

## Agent frameworks

Fetch the bearer from the [connect flow](/ai-agents/token-exchange) and inject it into the MCP client's HTTP headers.

<Tabs>
  <Tab title="LangChain">
    `MultiServerMCPClient` connects to the hosted endpoint over HTTP with a bearer header.

    <Tabs>
      <Tab title="TypeScript">
        ```ts theme={null}
        import { MultiServerMCPClient } from "@langchain/mcp-adapters";

        const client = new MultiServerMCPClient({
          walletsuite: {
            transport: "http",
            url: "https://mcp.walletsuite.io",
            headers: { Authorization: `Bearer ${token}` }
          }
        });
        ```
      </Tab>

      <Tab title="Python">
        ```python theme={null}
        from langchain_mcp_adapters.client import MultiServerMCPClient

        client = MultiServerMCPClient(
            {
                "walletsuite": {
                    "transport": "streamable_http",
                    "url": "https://mcp.walletsuite.io",
                    "headers": {"Authorization": f"Bearer {token}"},
                }
            }
        )
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="CrewAI">
    Add the hosted endpoint to the agent's `mcps` list with `MCPServerHTTP`.

    ```python theme={null}
    from crewai import Agent
    from crewai.mcp import MCPServerHTTP

    agent = Agent(
        role="Wallet Analyst",
        goal="Use WalletSuite tools inside a CrewAI workflow",
        backstory="Agent with access to WalletSuite MCP tools",
        mcps=[
            MCPServerHTTP(
                url="https://mcp.walletsuite.io",
                headers={"Authorization": f"Bearer {token}"},
                streamable=True,
            )
        ],
    )
    ```
  </Tab>

  <Tab title="Pydantic AI">
    Register the hosted endpoint as an `MCPServerStreamableHTTP` toolset.

    ```python theme={null}
    from pydantic_ai import Agent
    from pydantic_ai.mcp import MCPServerStreamableHTTP

    server = MCPServerStreamableHTTP(
        url="https://mcp.walletsuite.io",
        headers={"Authorization": f"Bearer {token}"},
    )

    agent = Agent("your-model", toolsets=[server])
    ```
  </Tab>

  <Tab title="Claude Agent SDK">
    Declare the hosted endpoint as an `http` MCP server in the run options.

    <Tabs>
      <Tab title="TypeScript">
        ```ts theme={null}
        import { query } from "@anthropic-ai/claude-agent-sdk";

        const response = query({
          prompt: "What's the ETH price right now?",
          options: {
            mcpServers: {
              walletsuite: {
                type: "http",
                url: "https://mcp.walletsuite.io",
                headers: { Authorization: `Bearer ${token}` }
              }
            }
          }
        });
        ```
      </Tab>

      <Tab title="Python">
        ```python theme={null}
        from claude_agent_sdk import query, ClaudeAgentOptions

        options = ClaudeAgentOptions(
            mcp_servers={
                "walletsuite": {
                    "type": "http",
                    "url": "https://mcp.walletsuite.io",
                    "headers": {"Authorization": f"Bearer {token}"},
                }
            }
        )
        ```
      </Tab>
    </Tabs>
  </Tab>
</Tabs>

## IDE and desktop hosts

<Note>
  IDE and desktop hosts are for prototyping, ad-hoc operator workflows, and demos. For production agent runs, use one of the frameworks above.
</Note>

Paste a fresh bearer from the [connect flow](/ai-agents/token-exchange) into the host's config. The bearer is short-lived — re-run the exchange when it expires.

<Tabs>
  <Tab title="Claude Desktop">
    Claude Desktop reads MCP servers from `claude_desktop_config.json`.

    * macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * Windows: `%APPDATA%\\Claude\\claude_desktop_config.json`

    If the file does not exist yet, create it.

    ```json theme={null}
    {
      "mcpServers": {
        "walletsuite": {
          "url": "https://mcp.walletsuite.io",
          "headers": {
            "Authorization": "Bearer <token>"
          }
        }
      }
    }
    ```

    After saving, fully restart Claude Desktop so it reloads MCP servers.
  </Tab>

  <Tab title="Claude Code">
    Add the hosted endpoint as an HTTP server with the bearer header:

    ```bash theme={null}
    claude mcp add --transport http walletsuite https://mcp.walletsuite.io \
      --header "Authorization: Bearer <token>"
    ```

    Add `--scope project` (a Claude CLI flag, not a WalletSuite option) to register the server in the project-level `.mcp.json` so your team shares the same config.

    Verify with `claude mcp list`.
  </Tab>

  <Tab title="Cursor">
    Cursor reads MCP servers from `mcp.json`.

    * Global: `~/.cursor/mcp.json`
    * Project: `.cursor/mcp.json`

    ```json theme={null}
    {
      "mcpServers": {
        "walletsuite": {
          "url": "https://mcp.walletsuite.io",
          "headers": {
            "Authorization": "Bearer <token>"
          }
        }
      }
    }
    ```

    Reload Cursor so it picks up the new server.
  </Tab>

  <Tab title="VS Code">
    VS Code reads MCP servers from `.vscode/mcp.json` in the workspace. Use the `servers` key with `type: "http"`.

    ```json theme={null}
    {
      "servers": {
        "walletsuite": {
          "type": "http",
          "url": "https://mcp.walletsuite.io",
          "headers": {
            "Authorization": "Bearer <token>"
          }
        }
      }
    }
    ```

    Start the server from the MCP view, then use it in an Agent-mode chat.
  </Tab>
</Tabs>

## Verify

With the agent connected at the read level, try:

* `What's the ETH price right now?`
* `Check balances for 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045`
* `Show me recent transactions for 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 on ethereum`

<Warning>
  **Authentication is required** — the bearer is missing, malformed, or expired. Re-run the [connect flow](/ai-agents/token-exchange) and re-attach a fresh `Authorization: Bearer <token>`.
</Warning>

## Next steps

<CardGroup cols={2}>
  <Card title="Connect Your Agent" icon="key" href="/ai-agents/token-exchange">
    How the agent authorizes and connects.
  </Card>

  <Card title="Execution Levels" icon="layer-group" href="/ai-agents/execution-levels">
    Move an agent from read-only to governed execution.
  </Card>

  <Card title="Trust Model" icon="shield-halved" href="/security/overview#trust-model">
    Non-custodial MPC signing — neither party holds the whole key.
  </Card>

  <Card title="Tool Reference" icon="wrench" href="/ai-agents/tool-reference">
    The full WalletSuite MCP tool surface.
  </Card>
</CardGroup>