Skip to content

MCP server

Jennah exposes agent memory, application datasets, approval requests and decisions, and managed agents over the Model Context Protocol (MCP). Compatible MCP hosts, such as Claude Code, Cursor, hosted agent runtimes, or custom agent loops, can read these resources through standard MCP tool calls, write to a configured memory scope, and request human approval.

You can connect using either of two transports, both of which expose the same tools:

  • Remote HTTP endpoint (https://jennah.alphaus.cloud/mcp): connects directly over HTTPS without local installation. Supported by hosted agent runtimes, the Anthropic and OpenAI APIs, Claude Code, Cursor, and custom servers.
  • jnh mcp CLI command: runs a local stdio subprocess for hosts that only support local MCP servers (such as Claude Desktop), forwarding requests to the remote endpoint using your jnh login session or an API key.

Access control and write scoping

  • Read access follows the credential. Read tools accept a target (a memory scope, dataset, or approval ID), which Jennah authorizes against the API key or user session using the same rules as the REST and gRPC APIs. Requests outside the credential's permissions return an authorization error rather than an empty result.
  • Write targets are fixed by the connection. Write tools do not accept a target parameter. remember_conversation writes only to the memory scope configured on the connection, and request_approval sends requests only to the configured approvers. A prompt injection cannot redirect writes to another scope or approver.

Restrict the API key to only the resources the host needs to read, as the MCP server grants access to everything the credential permits.

Tools

Group Tool Available
Orientation describe_reach Always
Memory recall_memory, inspect_memory Always
remember_conversation, formation_outcome With a memory scope configured
Datasets list_datasets, describe_dataset, query_rows Always (read-only)
Approvals list_approvals, get_approval Always
request_approval With approvers configured
Managed agents list_managed_agents, describe_managed_agent Always

Every tool still needs the matching permission on the credential: memory tools need agent.memory:read, dataset tools datastore.datasets:read, datastore.schema:read, and datastore.data:read, and approval reads approval.requests:read.

Remote endpoint

Configure your MCP host with the endpoint URL and an API key:

URL:    https://jennah.alphaus.cloud/mcp?memory=support.bot-01
Header: Authorization: Bearer jennah_sk_...

The query string is the connection's configuration:

Parameter Meaning
memory The memory scope (an agent workspace or a subject scope) that remember_conversation writes to and that memory reads default to. Leave it out for a host that only reads.
approver, quorum, approval_ttl The approval policy.

Unknown parameters are refused at connection rather than ignored. The endpoint uses MCP's streamable HTTP transport and is stateless across requests.

In the console, Connect via MCP (on the MCP page or an agent's page) generates an API key scoped to your selection and displays the endpoint URL and authorization header. You can select which agent or subject memory scopes and datasets the host may read (by ID or selector, such as support.* or guardrail.e2e.*), an optional memory scope for writes, and approvers. Opening the form from an agent's page pre-fills that agent. To create a key manually, see API keys.

Host configuration

Claude Code:

claude mcp add --transport http jennah \
  "https://jennah.alphaus.cloud/mcp?memory=support.bot-01" \
  --header "Authorization: Bearer $JENNAH_API_KEY"

Anthropic Messages API (MCP connector, beta header anthropic-beta: mcp-client-2025-11-20). Provide both the server connection in mcp_servers and a corresponding mcp_toolset entry in tools:

"mcp_servers": [{
  "type": "url",
  "url": "https://jennah.alphaus.cloud/mcp?memory=support.bot-01",
  "name": "jennah",
  "authorization_token": "jennah_sk_..."
}],
"tools": [{ "type": "mcp_toolset", "mcp_server_name": "jennah" }]

OpenAI Responses API and Agents SDK:

"tools": [{
  "type": "mcp",
  "server_label": "jennah",
  "server_url": "https://jennah.alphaus.cloud/mcp?memory=support.bot-01",
  "headers": { "Authorization": "Bearer jennah_sk_..." }
}]

Google ADK: Configure an MCPToolset with streamable HTTP connection parameters, the endpoint URL, and the Authorization header.

Claude Managed Agents: Add the endpoint as a remote MCP server and store the API key as its credential.

Hosts that require OAuth for remote MCP servers, such as claude.ai and ChatGPT connectors, are not yet supported. For Claude Desktop, use jnh mcp.

Local hosts: jnh mcp

For hosts that launch local MCP servers as stdio subprocesses, use jnh mcp, which is built into the jnh CLI:

{
  "mcpServers": {
    "jennah": {
      "command": "jnh",
      "args": ["mcp", "--memory", "support.bot-01"]
    }
  }
}

jnh mcp with no --memory serves a host that only reads. It uses the same authentication as other jnh commands: your jnh login session (automatically renewed when expired) or JENNAH_API_KEY in the server's env block. All flags can also be configured via environment variables:

Flag Environment variable
--memory JENNAH_MCP_MEMORY
--approver (repeatable) JENNAH_MCP_APPROVERS (comma-separated)
--quorum JENNAH_MCP_QUORUM
--approval-ttl JENNAH_MCP_APPROVAL_TTL

jnh mcp acts as a local stdio proxy to the remote endpoint. It requires network access to the platform, and server-side tool updates become available without upgrading jnh. With --memory, it checks at startup that the scope is reachable.

Hosts with built-in memory

Some hosts, such as Claude Code, include built-in memory features. When asked to remember something, the model may default to the host's built-in memory instead of Jennah's tools, especially if the host loads MCP tools on demand.

During initialization, the server returns instructions identifying itself as Jennah, the system of record for your agents, and describing when to use each group of tools. Hosts that include MCP server instructions in the model prompt pass these to the model. They describe the server's role without overriding the host's built-in memory.

To ensure the host uses Jennah for memory:

  • Specify the server in your prompt, for example, "use the jennah server to remember that I deploy on Fridays", or "recall from jennah what I said about deploys".
  • Add a standing instruction in the host configuration (CLAUDE.md or ~/.claude/CLAUDE.md in Claude Code, project instructions or personal preferences in Claude Desktop and claude.ai, or the system prompt in an agent framework):

    Use the jennah MCP server's tools as my memory: call recall_memory before
    answering anything that may depend on earlier conversations, and
    remember_conversation for anything worth keeping.
    

Tool reference

describe_reach

Reports what the connection can read and write: the memory scopes, datasets, and approvals accessible to the credential (up to 100 of each, with a truncation flag when more exist), the configured memory write scope, the configured approvers for request_approval, any managed agents with readable installations, and the available tools. It also indicates which capabilities are not configured and how to enable them. The server's initialization instructions direct the model to call this tool first.

recall_memory

Retrieves the remembered passages that semantically match a query, most relevant first, together with a bounded snapshot of the scope's knowledge graph assertions (entities and relationships). The graph snapshot is not filtered by the query: it covers up to 50 nodes and 50 edges.

Argument Description
query What to recall, as a question or topic (required)
limit Maximum passages to return (default 10)
scope The memory scope to read; defaults to the connection's memory scope, and is required without one

If nothing has been remembered yet, the tool returns an empty result without error.

Retrieved assertions include a qualified boolean flag. When false, the underlying assertion does not have verified currency (see temporal memory) and should not be treated as an active fact.

inspect_memory

Reads the facts and relationships stored in a memory scope, either currently or at a specified point in time (up to 100 nodes and 100 edges, with a truncation flag when more exist).

Argument Description
scope The memory scope to read; defaults to the connection's memory scope
asOf Read the graph as it stood at this time, in RFC 3339 (2026-11-01T00:00:00Z)

remember_conversation

Submits conversation turns for asynchronous formation into the connection's memory scope. Published only when one is configured; the tool takes no scope.

Argument Description
turns The conversation, in order: a list of {role, content} objects, where role is user, assistant, system, or tool

The call returns immediately upon acceptance with a formation handle. Processing continues asynchronously on the platform (see submitted formations). Handles are derived from the submitted content, so submitting the same conversation again resolves to the same handle without duplicate memories.

formation_outcome

Queries the status and results of a handle returned by remember_conversation, without blocking. The status is running, finished, nothing_written, failed (with a reason), or unknown_handle (the record expired, or it belongs to another scope). Handle records are retained for 7 days after completion; committed memories remain queryable with recall_memory.

list_datasets

Lists the datasets accessible to the credential, with an optional prefix filter (such as guardrail.) and a pageToken for pagination.

describe_dataset

Describes one dataset (datasetId): its tables, each table's columns and types, primary key, retention, and whether the table is ready.

query_rows

Reads rows from a single table (read-only).

Argument Description
datasetId, table What to read (required)
where Filters, each column<op>value with op one of =, <, <=, >, >=; all must hold. There is no OR or !=. A timestamp is RFC 3339.
orderBy Columns, each column or column:desc
select Columns to return; all when left out
limit Rows to return, at most 100 (default 20)
pageToken The nextPageToken from a previous call with the same query

Filters are validated against each column's declared type using the same grammar as jnh datasets query, and invalid columns or values are rejected before execution. Each returned row is an object keyed by column name, with JSON columns returned as parsed values.

list_approvals

Lists approval requests accessible to the credential in reverse chronological order, optionally filtered by status (pending, approved, rejected, expired, cancelled, answered), returning up to 50 items per page with a pageToken for pagination.

get_approval

Retrieves a single approval request by approvalId, including its title, summary, status, list of recipients and delivery status, and all recorded decisions (reviewer, timestamp, and whether submitted via email link or signed-in session). Only the approved status authorizes a gated action; requests that pass their deadline without a decision transition to expired and must be treated as denied. This tool returns immediately without waiting for a decision.

request_approval

Creates an approval request for the configured approvers and returns immediately with an approval ID and pending status. Available only when approvers are configured.

Argument Description
title Short title for the action shown to approvers (required)
summary Markdown description of the intended action and rationale (required)
payload Structured parameters for the action, such as an amount or target, displayed alongside the summary

Requests are deduplicated using a key derived from the title, summary, payload, memory scope, and approval policy, so repeating an identical request returns the existing approval without sending duplicate notifications. When the memory scope is an agent workspace, the request is raised for that agent.

list_managed_agents

Lists the managed agents operated by Jennah, such as the AWS Spend Guardrail, along with the installations whose datasets are accessible to the credential (for the guardrail, one per MSP and payer account).

describe_managed_agent

Returns documentation for a managed agent by id, including its purpose, dataset naming conventions, how to query its current state, and event kind definitions. For the AWS Spend Guardrail, the current state is stored in the most recent heartbeat event in the payer organization's inbox, which can be queried with a single query_rows call:

query_rows  datasetId=guardrail.<msp>.<payer>.inbox  table=events
            where=["kind=heartbeat"]  orderBy=["occurred_at:desc"]  limit=1

Approvals

request_approval lets an agent ask people to authorize an action before taking it. Recipients, quorum, and request expiration are fixed in the connection's configuration and cannot be set or modified by tool arguments, preventing prompt injection from altering who is asked.

For the remote endpoint, pass these settings as query parameters:

https://jennah.alphaus.cloud/mcp?memory=support.bot-01
  &approver=lead@acme.example
  &approver=ops@acme.example
  &quorum=all
  &approval_ttl=2h

For jnh mcp, pass the corresponding flags (or environment variables):

jnh mcp --memory support.bot-01 \
  --approver lead@acme.example --approver ops@acme.example \
  --quorum all --approval-ttl 2h
Setting Meaning
approver Recipient email address. Repeat to specify multiple approvers. If omitted, request_approval is not published.
quorum any (default): resolves on the first approval. all: requires every listed approver to approve.
approval_ttl Request expiration duration, such as 2h. Defaults to the platform default (72h).

Requirements:

  • The credential requires approval.requests:create and approval.requests:read. Connect via MCP includes these automatically when approvers are specified.
  • External approvers must be listed on the organization's approver allowlist.
  • Requests count toward the plan's approval limits.

As with the Approvals API, Jennah records the request and decision, but does not intercept or block tool execution. Critical actions should be enforced in the code that executes them.

Protocol and standard I/O

The remote endpoint responds to each request with a JSON payload and does not hold sessions or streams open.

jnh mcp communicates using newline-delimited JSON-RPC over standard input and output. All operational logs, diagnostics, and errors are written to standard error. Because standard output is reserved for protocol frames, jnh mcp rejects explicit output formatting flags such as -o json, and ignores JENNAH_OUTPUT.

Troubleshooting

Remote endpoint connection errors

  • 401: missing Authorization: Bearer ... header, or the API key is expired or revoked.
  • 404: the request path is not /mcp. Requests to the legacy /mcp/{workspace} path return an error indicating the /mcp?memory={workspace} form.
  • 400: unknown query parameter, memory given twice, an invalid quorum or approval_ttl, or quorum without an approver. The response names the parameter.
  • 403: request originated from a browser. Browser requests are not supported on this endpoint.
  • A connection error saying the credential was refused, or the memory scope is not reachable: the key is invalid, or the scope does not exist or the key's selectors do not cover it.

jnh mcp exits immediately

Check the host's server log (stderr). Common causes include:

  • Memory scope unreachable: verify that the --memory scope exists and the API key or session can reach it.
  • Unauthenticated session: run jnh login or provide a valid JENNAH_API_KEY.
  • the platform at this endpoint does not serve MCP yet: the platform is running a version without remote MCP support.
  • Expired session: session expired (run: jnh login) means the stored login can no longer be renewed.

Some hosts do not show the server's stderr. Claude Code, for example, reports only CONNECTION_CLOSED in claude mcp list. To see the reason, run the same command the host runs, at a terminal, with its input closed:

jnh mcp --memory <scope> </dev/null

If startup succeeds, it prints nothing and exits. Otherwise it prints the reason on one line.

Session disconnects during handshake

If the host disconnects immediately without an error, check stderr for a protocol version mismatch. The MCP lifecycle specification requires the server to answer with a version it supports; the host disconnects if it cannot speak that version. Update the host application to resolve it.

Tool calls denied

A denial indicates that the credential lacks the required permission or its selectors do not cover the target resource. The server returns an error describing the denial rather than an empty result. Call describe_reach to inspect the connection's accessible resources, or review the API key configuration.

Model does not invoke tools

Verify in the MCP host's settings that the server is active and connected. If it is, tool invocation depends on the host's system instructions and prompt configuration; a standing instruction (see Hosts with built-in memory) helps.