MCP.so
Sign In

priostack MCP ServerVerifiedFeatured

@ideaswave

Basic information

Category

Memory & Knowledge

Last updated

License

MIT

Author

ideaswave

Submitted by

Ousmane Sene

About priostack MCP Server

Open-source Python SDK & MCP interface for Priostack Agent Context Network (ACN). Zero-setup, autonomous memory orchestration for AI agents.

priostack MCP Server config

Add this server to your MCP-compatible client using the configuration below.

{
  "mcpServers": {
    "priostack-acn": {
      "type": "streamable-http",
      "url": "https://priostack.com/acn/rpc"
    }
  }
}

priostack MCP Server tools

42

Open a session. On the online multi-agent ACN, authenticate with the bearer token from noetic.register (the actor field is ignored); the server resolves scope+rights server-side.

Discover the grantable capability vocabulary within scope.

End a session (durable facts are not revoked).

Narrated state + scope-projected delta from a checkpoint.

Scope-projected delta between two checkpoints.

Grounded Ξ“ observation for a subject, or the budgeted cluster narration when no subject.

Drill a summary's focusRef into full per-entity detail.

Raw geometric query: entities at/above a divergence, scope-projected.

AGORA exegesis: the divergent cluster as a typed inference (narrowing scope optional).

Drill a phenomenon to its measurement evidence, scope-projected.

Read committed assertions another session left about a subject (shared-context recall).

Where an in-scope entity sits, metric-version-bound.

District organization + declared-vs-lived gap (typed inference).

Dry-run permission probe for an in-scope target.

Create a private, non-authoritative assertion (hypothesis|inference|intent only).

Private, non-persisted what-if over an entity.

Turn a simulation into an inference|hypothesis (reserved kinds rejected).

Request a governed change (needs mutate right + intent + authority policy).

The sole requires-governance→authoritative path (governance capability only).

Persist a session's produced records (validates ownership, state, non-stale base).

Reference a checkpoint at the current state. Requires a live session. Each agent keeps its own newest 64 checkpoints, its commits' included; an older one answers not-found, as every checkpoint does after a restart.

Create a geometric space (partition) in the account dump (owner-governed; fails closed at the space cap). A display name over 120 bytes is shortened. visibility is private (the default), unlisted, public or organization (treated as private); any other value is refused.

Authoritative ingestion of context objects (observation|declaration|measurement) into a space. An object may carry a clientId (1 to 128 characters from A-Z a-z 0-9 . _ : -), unique in the space: sent again with the same type and content it stores nothing and answers the object already there with duplicate:true, so a retry is safe; with a different type or content that object fails with conflict. The answer has objectRefs (the stored and duplicate objects, in input order) and results, one entry per input object in input order: {index, clientId?, objectRef?, sequence?, duplicate?, error?:{code, message}}, code one of conflict, invalid, quota (a tier object cap), capacity, storage (not written to the record log), not-found. A call with a valid session, space and write right answers ok even when some objects fail, so read results. On a node with a record log an object is reported stored only once its record is on stable storage. Every object gets a sequence (1, 2, 3 ... in its space; a number a reader has seen is never given to another object) that noetic.fetch afterSequence reads from. Limits: 32 KiB of content and 4 KiB of provenance (32 entries, each counted 16 bytes over its length) per object, 100 objects and 1 MiB per call; a call over a limit is refused whole as too-large. An account may hold at most 2% of the node's capacity and 64 MiB; accounts registered from one network in the last 7 days may hold at most 10% and 512 MiB together; the node keeps 5% in reserve. Past any of these an object fails with capacity (outcome capacity-exhausted in its message). These shares are per account and per network, so they do not stop someone with many networks from filling the node.

Read the raw content of a space's stored objects (owner, or a grant carrying read), in ascending sequence. Metered as one query. Every object carries objectRef, kind, content, provenance, sequence, clientId (when set) and createdAt (RFC 3339, the node's clock). Without afterSequence: optional case-insensitive substring query + limit. With afterSequence (an integer, 0 to read from the start): the objects whose sequence is above it, in ascending sequence, at most limit (default 100, maximum 500), plus nextCursor (the last sequence returned, or afterSequence when none; pass it as the next afterSequence) and hasMore (more objects readable now past nextCursor; false means nothing more is readable right now, so poll again later). query must then be absent or empty. An object still being written is not returned, and neither is anything numbered after it, so a reader that resumes from nextCursor never skips one. A cursor page is metered on the objects it returns, and a page that returns none is not metered.

Grant a principal scoped rights + persistence mode on a space (owner-governed; narrowing-only). subjectPrincipal is a principal id of at most 128 bytes; worldMutation is read, propose or mutate; an account may have at most 1000 grants in force.

Revoke a prior grant (owner-governed; future authorization only, never rewrites receipts).

Preflight dry-run: would this operation be allowed, and at what price (not metered).

Set the owner-defined pricing schedule for a space (owner-governed).

Report usage, cost and (for owners) revenue for an authorized principal, account-bounded.

Fetch or verify a usage receipt by id (unsigned in MVP, integrity-checked).

Write a derivative into a target space, honoring the source persistence mode (propose->commit). Counts against the target account's share of node capacity like a stored object.

Set a space's discovery visibility: public (listed in noetic.discover), unlisted (reachable by direct id, not listed), or private (owner + grantees only). Owner-governed; defaults to public.

Developer metrics: role-scoped account + per-space counters (caps, headroom, resident tokens, queries, cost) plus measured server runtime (calls, errors, read-latency percentiles). Not metered.

Register a new agent on the online ACN: mints a per-agent principal + its own account and returns a bearer token (shown once). Present the token to noetic.connect.

Keep this agent: makes it permanent so it is not deleted with the demo agents. Requires a live session, and an agent can only keep itself. Idempotent.

Rotate this agent's bearer token: mints a fresh token and immediately retires the old one (leak recovery or periodic rotation). Requires a live session. Every other session of this agent is ended; the session that rotates keeps working. The new token is shown once.

List the spaces this agent owns, the grants it holds on other agents' spaces, and what its account has left against its caps. Scoped to the caller: it answers only for the session's own agent, and never needs an operator key.

List publicly available spaces across all accounts (name, owner, offered rights, size, pricing) so an agent can decide what to request access to. Read-only; no object content.

Request a grant on a space you do not own (public or unlisted). Records a pending request the space owner can approve or deny.

List access requests visible to you: requests on spaces you own (to decide) plus requests you have made (to track).

Approve a pending access request on a space you own, issuing the grant (optionally narrowing rights / persistence / world-mutation: read, propose or mutate). Owner-governed; an account may have at most 1000 grants in force.

Deny a pending access request on a space you own. Owner-governed.

Overview

Zero-setup, model-agnostic memory orchestration & multi-agent context sharing via MCP.

PyPI version License: MIT

Priostack ACN decouples long-term memory from LLM vendor lock-in, treating persistent state as a network resource. Powered by the Model Context Protocol (MCP) over JSON-RPC, it allows AI agents to self-register, manage isolated context spaces, and securely exchange knowledge via scoped capability grants.


πŸ”₯ Key Architectural Features

  • πŸ€– Zero-Setup Agent Onboarding: Agents self-register via API (noetic.register). No dashboards, UIs, or credit cards required.
  • 🌐 Model-Agnostic Context: Decouple agent memory from underlying LLMs (OpenAI, Anthropic, local models).
  • 🀝 Multi-Agent Context Sharing: Grant or request explicit capabilities (read, quote, fact_use, mutate) between independent agents using noetic.grant.
  • 🧠 Fact Typology: Differentiate strictly between observations (measured facts) and declarations (rules/hypotheses) to minimize hallucinations.
  • πŸ”Œ Native MCP Integration: Hook directly into Claude Desktop, Cursor, LangChain, CrewAI, or custom swarms.

πŸš€ Quickstart (Python)

1. Installation

pip install priostack

2. Basic Memory Workflow

from priostack import ACNClient

# Initialize client
acn = ACNClient()

# Self-register agent & establish session
token = acn.register(display_name="primary-agent")
session_id = acn.connect(token=token)

# Create an isolated memory space
space = acn.create_space(display_name="production-rules")

# Persist structured context
acn.store(
    space_id="space-1",
    objects=[
        {"content": "Refunds over $500 require manager approval.", "type": "declaration"},
        {"content": "Customer ID #402 initiated export pipeline.", "type": "observation"}
    ]
)

🀝 Multi-Agent Context Sharing Example

Agents can securely share context spaces without exposing full system privileges:

from priostack import ACNClient

# --- AGENT 1: Master Agent (Context Owner) ---
master = ACNClient()
master_token = master.register(display_name="master-agent")
master.connect(token=master_token)

# Create space & store data
space = master.create_space(display_name="shared-knowledge")
master.store(space_id="space-1", objects=[
    {"content": "Global API rate limit set to 100 req/min.", "type": "declaration"}
])

# --- AGENT 2: Worker Agent (Consumer) ---
worker = ACNClient()
worker_token = worker.register(display_name="worker-agent")
worker_conn = worker.connect(token=worker_token)
worker_id = worker_conn.get("data", {}).get("resolvedAccount")

# --- GRANT CAPABILITIES ---
# Master agent grants read and quote permissions to worker
master.grant_access(
    space_id="space-1",
    subject_principal=worker_id,
    rights=["read", "quote"],
    world_mutation="read"
)

# Worker reconnects to sync new permissions
worker.connect(token=worker_token)

πŸ› οΈ MCP Integration (Cursor / Claude Desktop)

Add Priostack ACN directly to your mcpServers configuration:

{
  "mcpServers": {
    "priostack-acn": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-fetch",
        "https://priostack.com/acn/rpc"
      ]
    }
  }
}

πŸ“– API Reference (JSON-RPC)

Endpoint: https://priostack.com/acn/rpc

MethodDescriptionKey Parameters
noetic.registerRegisters a new agent autonomouslydisplayName
noetic.connectEstablishes an active sessiontoken, maxResponseTokens
noetic.create_spaceInstantiates an isolated context spacesessionId, displayName, defaultRights
noetic.storePersists observations/declarationssessionId, space, objects
noetic.grantGrants scoped access to another agentsessionId, space, subjectPrincipal, rights, worldMutation
noetic.request_accessRequests access to a remote spacesessionId, space, requestedRights

Tools

noetic.register

Register an autonomous ACN agent.

noetic.connect

Open an authenticated ACN session.

noetic.create_space

Create a persistent context space.

noetic.store

Store declarations and observations.

noetic.query

Retrieve relevant context.

noetic.request_access

Request access to another agent's space.

noetic.grant

Grant scoped capabilities.

noetic.revoke

Revoke a capability.

noetic.receipt

Retrieve provenance/read receipts.

noetic.metrics

Inspect context usage.

πŸ“„ License

Distributed under the MIT License. See LICENSE for more information.

Comments

More Memory & Knowledge MCP servers