# Set up Flexpa's health tool search

Use these instructions when a user asks you to connect to Flexpa's health tool search from Health tools for agents (https://www.flexpa.com/agents). The connection uses MCP to discover health tools and their setup instructions.

- Name: `flexpa`
- Server URL: `https://api.flexpa.com/mcp`
- Transport: Streamable HTTP (remote MCP)
- Authentication: none for the public registry and endpoint directory
- A Flexpa account, API key, and demo signup are not needed for this connection.

Identify your MCP client and use the matching instructions below. Merge the entry into existing configuration; keep other servers and settings. Do not add duplicate entries. If your client cannot install connections itself, give the user the appropriate setup steps.

## Claude Code

Run in the project that should use the connection:

```sh
claude mcp add flexpa --transport http https://api.flexpa.com/mcp
```

Start Claude Code in that project to use the connection.

## Hermes

```sh
hermes mcp add flexpa --url https://api.flexpa.com/mcp
```

Run `/reload-mcp` in Hermes, or start a new session.

Alternatively, merge this into `~/.hermes/config.yaml`:

```yaml
mcp_servers:
  flexpa:
    url: https://api.flexpa.com/mcp
```

[Official Hermes MCP documentation](https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp)

## OpenCode

Run in the project that should use the connection:

```sh
opencode mcp add flexpa --url https://api.flexpa.com/mcp
```

Alternatively, merge this into the project's `opencode.jsonc`. OpenCode 2 reads server names under `mcp.servers`:

```json
{
  "mcp": {
    "servers": {
      "flexpa": {
        "type": "remote",
        "url": "https://api.flexpa.com/mcp",
        "oauth": false
      }
    }
  }
}
```

Run `opencode mcp list` to check the connection.

[Official OpenCode MCP documentation](https://opencode.ai/v2/docs/mcp-servers)

## Claude web or desktop

1. Open [custom connectors](https://claude.ai/settings/connectors?modal=add-custom-connector).
2. Add a connector named Flexpa with URL `https://api.flexpa.com/mcp`.
3. Connect without authentication for the public registry.

## Clients using mcpServers JSON

Merge this entry into the client's MCP configuration:

```json
{
  "mcpServers": {
    "flexpa": {
      "type": "http",
      "url": "https://api.flexpa.com/mcp"
    }
  }
}
```

Save and reconnect the client. Other clients can use the same remote server URL with their documented configuration format.

## Verify and discover

Check that the connection exposes `search_tools` and `execute_tool`. Then call `search_tools` with:

```json
{
  "query": "MCP server",
  "include_locked": true,
  "kind": "mcp_server"
}
```

This includes entries that need their own connection. For a result with `kind: "tool"`, use its schema and namespaced name with `execute_tool`. For `kind: "mcp_server"`, use its direct connection instructions. The registry does not proxy partner tools. A connection without a patient token cannot read personal health records; patient records need a Flexpa Consent authorization.

Once connected, ask what the user would like help with if they have not already said. Call `search_tools` with that task as the query and `include_locked: true` to include tools that need another connection. Explain relevant matches and any additional setup they need.

To find individual provider tools, search with `kind: "mcp_tool"` and `include_locked: true`, for example `query: "meal plan"` or `query: "search_care_prices"`. Results include the owning `serverName`, original `toolName`, source, and connection details. Connect to that server, inspect its current `tools/list`, and call the original `toolName` there. If `schemaStatus` is `requires_connection`, the registry does not have a complete input schema. A call to `execute_tool` for an indexed tool returns direct-connection guidance.

Flexpa Consent, Arlo Health, Genome Computer, and Function Health require separate authorization.

Trophe and Kinbook are open-source local tools from Flexpa. They use stdio and need no account, API key, or OAuth:

- **Trophe** stores a nutrition journal in local Markdown files. Requires Bun 1.3.13 or newer. Clone https://github.com/flexpa/trophe, run `bun install`, and add `bun src/cli.ts mcp` as a stdio server with the repository as its working directory. Use an absolute path to `src/cli.ts` if the client runs elsewhere. Data defaults to `~/.trophe`; pass `--data` with an absolute path to choose another directory. Call `init_journal` with the user's timezone before logging meals in a new journal. Agents with shell access can also use the CLI. Read the [Trophe setup guide](https://github.com/flexpa/trophe#agent-setup) and [agent skill](https://github.com/flexpa/trophe/blob/main/SKILL.md).
- **Kinbook** stores a family tree in a local SQLite file. Requires Bun. Clone https://github.com/flexpa/kinbook, run `bun install`, and add `bun packages/mcp-server/src/index.ts` as a stdio server with the repository as its working directory. Pass `--db` with an absolute path to choose the SQLite file. Read the [Kinbook setup guide](https://github.com/flexpa/kinbook#readme) and [agent skill](https://github.com/flexpa/kinbook/blob/master/SKILL.md).

### Remote privacy policies

Read each provider's privacy policy before authorizing a connection:

- [Flexpa](https://www.flexpa.com/docs/privacy)
- [Arlo Health](https://www.arlohealth.ai/privacy)
- [Genome Computer](https://genome.computer/privacy)
- [Function Health](https://www.functionhealth.com/legal/privacy-policy)

Remote connection metadata includes `privacyPolicyUrl` in search results and connection guidance.

### Flexpa Health Bridge

[Flexpa Health Bridge](https://github.com/flexpa/bridge) is a macOS-only research app for local access to Apple Health data from iPhone and Apple Watch. It requires macOS 14 or later and a recent Swift toolchain. Read the setup and security guides before building the app. Import an encrypted iPhone backup or Health export; live HealthKit sync is not available.

Read the repository's setup and security guides before use. Pair each agent in the app, then use the generated configuration for its local MCP endpoint at `http://127.0.0.1:4271/mcp`. The app must stay running. It uses a per-agent bearer token, not OAuth. Let the MCP client make the token's first request; a test with `curl` would bind the token to the wrong process. Search for `Flexpa Health Bridge` with `include_locked: true` and `kind: "mcp_server"` for setup details.

### OpenMed local models

[OpenMed on Hugging Face](https://huggingface.co/OpenMed) provides medical named entity recognition (NER) models that agents can run locally. Carefully read the [OpenMed documentation](https://openmed.life/docs) and the selected model card before use. Check the entity labels, language, license, runtime requirements, and limitations. Download the selected model, run inference locally, and review its extracted entities before use.

Search for `OpenMed NER` with `include_locked: true` and `kind: "local_resource"`. This entry is a model repository link. It has no MCP endpoint or executable input schema. `execute_tool` returns `local_setup_required` with the repository, documentation, requirements, and usage guidance.

Install additional services only when the user requests them.

[Full registry documentation](https://www.flexpa.com/docs/guides/mcp-registry)