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 mcpCLI 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 yourjnh loginsession 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_conversationwrites only to thememoryscope configured on the connection, andrequest_approvalsends 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:
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.mdor~/.claude/CLAUDE.mdin Claude Code, project instructions or personal preferences in Claude Desktop and claude.ai, or the system prompt in an agent framework):
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:createandapproval.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: missingAuthorization: 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,memorygiven twice, an invalidquorumorapproval_ttl, orquorumwithout anapprover. 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
--memoryscope exists and the API key or session can reach it. - Unauthenticated session: run
jnh loginor provide a validJENNAH_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:
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.