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 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)

/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.

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”.

Codex

# ~/.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

// ~/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

// ~/.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

{
  "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)

claude mcp add --transport http nous https://mcp.opennous.cloud/mcp --header "Authorization: Bearer YOUR_API_KEY"

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.

The 25 tools

Read and write the context graph

get_context

Engineered context for a task about one entity — the headline call before drafting outreach or prepping a meeting.

get_account

The full account — every claim with epistemics + recent timeline.

record

Record what happened. You observe; Nous derives the claims.

query

Retrieve + summarise a corpus of activity across many people.

attention

What needs your attention — accounts gone quiet, facts decayed.

verify

Re-check one claim before acting on it.

get_gtm_profile

The user’s own GTM profile — ICP, market, pricing, competitors.

update_gtm_profile

Write back a lasting change to a GTM section — it evolves, keeping history.

save_note

Keep a meeting brief, transcript, or note on a contact’s record.

search_notes

Semantic search across saved notes & documents — pull the relevant passage.

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.

get_workspace_status

The whole setup state + a ranked next-steps list. The first call in a session.

set_workspace_profile

Agent-driven onboarding — set name, website, business type, and ICP.

build_scoring_model

Build the ICP scoring model from the recorded GTM context.

connect_integration

Connect a key-based integration (Apollo, Prospeo, HubSpot token, …).

configure_crm_sync

Set the CRM sync rules — auto-sync, create policy, hygiene cadence.

set_trigger

Create an outbound event trigger (webhook) for the user’s stack.

list_triggers

List the workspace’s triggers + the catalog of available events.

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.

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.

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.

Source + versioning

The server lives at apps/mcp in NousC/nous. Each release is published to npm as @opennous/mcp@<semver> — pin a version in your config if you need reproducible installs:

NOUS_API_KEY=... npx -y @opennous/mcp@0.28.0