> ## Documentation Index
> Fetch the complete documentation index at: https://proply-rm-lead-list-docs.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server

> @opennous/mcp — give Claude Code, Codex, Cursor, and any MCP-compatible client one call into the Nous context graph.

The Nous MCP server exposes the v2 context graph as **25 tools** — engineered, epistemics-tagged context, never raw rows. The agent also sets the workspace up itself: onboard it, build the GTM playbook, connect key-based tools, configure CRM sync, wire triggers. Nous is operated by the agent; the web app is where you watch it. **Call `get_workspace_status` first.**

It runs two ways on the same tools: **locally** via `npx` (Claude Code, Cursor, Codex, Claude Desktop, self-hosted n8n), or **hosted** over Streamable HTTP at `https://mcp.opennous.cloud/mcp` for cloud clients (n8n cloud). Prefer the [REST API](/public-api/introduction) when the caller already knows the parameters; both sit on the same graph, so a write through one shows in the other.

## Install in 30 seconds

The server is published on npm. **No clone, no global install** — `npx` fetches it on first use.

### Claude Code (recommended)

```bash theme={null}
/plugin marketplace add NousC/nous
/plugin install nous@nous-plugins
npx @opennous/cli login
```

`npx @opennous/cli login` opens your browser, you approve, and a workspace key is minted and saved — no copy-paste; the plugin's MCP picks it up. Then tell your agent **"set me up"**. (Prefer to paste a key? Create one at Settings → API Keys and set the plugin's `NOUS_API_KEY`.) 25 tools become callable in every Claude Code session.

<Note>
  **Every client below can skip the key.** The configs show `NOUS_API_KEY = "YOUR_API_KEY"` only as a fallback — you can drop that `env` line and run **`npx @opennous/cli login`** once. It signs you in via the browser and saves the key to `~/.nous/config.json`, which the server reads automatically. Paste a key only to pin a specific one (create it at Settings → API Keys). Either way, then tell your agent **"set me up"**.
</Note>

### Codex

```toml theme={null}
# ~/.codex/config.toml — no env key needed; run `npx @opennous/cli login` once
[mcp_servers.nous]
command = "npx"
args = ["-y", "@opennous/mcp"]
# env = { NOUS_API_KEY = "YOUR_API_KEY" }   # optional — pins a specific key
```

### Claude Desktop

```json theme={null}
// ~/Library/Application Support/Claude/claude_desktop_config.json    (macOS)
// %APPDATA%\Claude\claude_desktop_config.json                        (Windows)
{
  "mcpServers": {
    "nous": {
      "command": "npx",
      "args": ["-y", "@opennous/mcp"],
      "env": { "NOUS_API_KEY": "YOUR_API_KEY" }
    }
  }
}
```

### Cursor

```json theme={null}
// ~/.cursor/mcp.json   (or .cursor/mcp.json in a project for project-scoped)
{
  "mcpServers": {
    "nous": {
      "command": "npx",
      "args": ["-y", "@opennous/mcp"],
      "env": { "NOUS_API_KEY": "YOUR_API_KEY" }
    }
  }
}
```

### Any MCP-compatible client

```json theme={null}
{
  "mcpServers": {
    "nous": {
      "command": "npx",
      "args": ["-y", "@opennous/mcp"],
      "env": { "NOUS_API_KEY": "YOUR_API_KEY" }
    }
  }
}
```

## Hosted server (remote HTTP)

Cloud clients that can't launch a local process — **n8n cloud** above all, and any client that takes a remote MCP URL — connect to the hosted Nous MCP server over Streamable HTTP. Same 25 tools, same context graph; a write through one transport is visible to the other. Authenticate per request with your workspace API key as a Bearer token.

```
Endpoint   https://mcp.opennous.cloud/mcp
Auth       Authorization: Bearer YOUR_API_KEY
```

### n8n cloud

Add an **MCP Client Tool** node and configure it:

* **Server Transport** → `HTTP Streamable`
* **Endpoint URL** → `https://mcp.opennous.cloud/mcp`
* **Authentication** → `Bearer Auth`, token = your Nous API key

### Claude Code (remote)

```bash theme={null}
claude mcp add --transport http nous https://mcp.opennous.cloud/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

<Note>
  Clients that accept only a bare URL with no auth header can pass the key as a query parameter — `https://mcp.opennous.cloud/mcp?key=YOUR_API_KEY` — but prefer the Bearer header, since URLs can land in logs.
</Note>

## The 25 tools

### Read and write the context graph

<CardGroup cols={2}>
  <Card title="get_context" href="/mcp/tools/get-context" icon="brain">
    Engineered context for a task about one entity — the headline call before drafting outreach or prepping a meeting.
  </Card>

  <Card title="get_account" href="/mcp/tools/get-account" icon="user">
    The full account — every claim with epistemics + recent timeline.
  </Card>

  <Card title="record" href="/mcp/tools/record" icon="pen">
    Record what happened. You observe; Nous derives the claims.
  </Card>

  <Card title="query" href="/mcp/tools/query" icon="magnifying-glass">
    Retrieve + summarise a corpus of activity across many people.
  </Card>

  <Card title="attention" href="/mcp/tools/attention" icon="bell">
    What needs your attention — accounts gone quiet, facts decayed.
  </Card>

  <Card title="verify" href="/mcp/tools/verify" icon="shield-check">
    Re-check one claim before acting on it.
  </Card>

  <Card title="get_gtm_profile" href="/mcp/tools/get-gtm-profile" icon="book">
    The user's own GTM profile — ICP, market, pricing, competitors.
  </Card>

  <Card title="update_gtm_profile" href="/mcp/tools/update-gtm-profile" icon="book-open">
    Write back a lasting change to a GTM section — it evolves, keeping history.
  </Card>

  <Card title="save_note" href="/mcp/tools/save-note" icon="note-sticky">
    Keep a meeting brief, transcript, or note on a contact's record.
  </Card>

  <Card title="search_notes" href="/mcp/tools/search-notes" icon="file-magnifying-glass">
    Semantic search across saved notes & documents — pull the relevant passage.
  </Card>
</CardGroup>

### Operate the workspace (setup)

The agent sets the workspace up itself. Call `get_workspace_status` first; it returns a ranked list of what to do next.

<CardGroup cols={2}>
  <Card title="get_workspace_status" href="/mcp/tools/get-workspace-status" icon="gauge">
    The whole setup state + a ranked next-steps list. The first call in a session.
  </Card>

  <Card title="set_workspace_profile" href="/mcp/tools/set-workspace-profile" icon="id-card">
    Agent-driven onboarding — set name, website, business type, and ICP.
  </Card>

  <Card title="build_scoring_model" href="/mcp/tools/build-scoring-model" icon="sliders">
    Build the ICP scoring model from the recorded GTM context.
  </Card>

  <Card title="connect_integration" href="/mcp/tools/connect-integration" icon="plug">
    Connect a key-based integration (Apollo, Prospeo, HubSpot token, …).
  </Card>

  <Card title="configure_crm_sync" href="/mcp/tools/configure-crm-sync" icon="database">
    Set the CRM sync rules — auto-sync, create policy, hygiene cadence.
  </Card>

  <Card title="set_trigger" href="/mcp/tools/set-trigger" icon="bolt">
    Create an outbound event trigger (webhook) for the user's stack.
  </Card>

  <Card title="list_triggers" href="/mcp/tools/list-triggers" icon="list">
    List the workspace's triggers + the catalog of available events.
  </Card>
</CardGroup>

<Note>
  Also callable: **`record_closed_deals`** (train the ICP model on real closed-won/lost deals — contrastive lift) and **`get_routing_preferences`** (Claude Code routing defaults so GTM work defaults to Nous). Plus `get_workspace_facts`, a back-compat alias of `get_gtm_profile` — new integrations should call `get_gtm_profile`.
</Note>

## Environment

| Variable       | Required | Default                      | Purpose                                           |
| -------------- | -------- | ---------------------------- | ------------------------------------------------- |
| `NOUS_API_KEY` | yes      | —                            | Workspace API key. Create at Settings → API Keys. |
| `NOUS_API_URL` | no       | `https://api.opennous.cloud` | Override for self-hosted.                         |

The preferred path is `npx @opennous/cli login` — a browser sign-in that mints a workspace key and saves it to `~/.nous/config.json`, which the MCP reads (no `NOUS_API_KEY` to set). The plugin's `userConfig` field still accepts a pasted key as a fallback, stored in your OS keychain — never in plaintext or shell history.

## How agents typically use it

**Setting up a new workspace** → `get_workspace_status` to see what's missing, then `set_workspace_profile` (onboard), `update_gtm_profile` + `build_scoring_model` (the GTM playbook), `connect_integration` (key-based tools), `configure_crm_sync`, and `set_trigger`. The agent does the setup; the user just confirms. OAuth tools (Gmail) stay a one-click browser step on the Integrations page.

Day to day:

1. **Start of a task** → `get_context` with the right `intent` to get a ranked, budget-fit context block
2. **Action happens** → `record` an observation (an email was sent, a state changed)
3. **Produced something durable?** → `save_note` the brief / transcript / prep onto the contact so the record builds across meetings
4. **Need a past detail?** → `search_notes` to pull the relevant passage instead of dumping whole documents
5. **Stale-looking fact?** → `verify` before acting on it
6. **End of session** → `attention` to surface what to work next

`get_gtm_profile` is the meta-tool: any question about the user's own business (ICP, pricing, market) goes here, never to `query`/`get_account`. When the business itself changes (repriced, moved upmarket, sharpened positioning), `update_gtm_profile` writes the change back so the context stays current.

<Note>**`record` vs `save_note`.** `record` logs that *something happened* (an email, a meeting, a state change) — Nous derives claims from it. `save_note` keeps the *document itself* (a brief, a transcript, prep) on the contact, append-only and dated. Use both: `record` the meeting happened, `save_note` the notes you took.</Note>

## Source + versioning

The server lives at [`apps/mcp` in NousC/nous](https://github.com/NousC/nous/tree/main/apps/mcp). Each release is published to npm as `@opennous/mcp@<semver>` — pin a version in your config if you need reproducible installs:

```bash theme={null}
NOUS_API_KEY=... npx -y @opennous/mcp@0.28.0
```