Mnemoverse

https://mnemoverse.com/docs
Admin
Mnemoverse is a persistent memory API for AI agents that enables them to write preferences,...
Tokens:139,199
Snippets:2,153
Trust Score:6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Mnemoverse SDK

Source: https://mnemoverse.com/docs/api/python-sdk

Use pip to install the package. Requires Python 3.10 or higher.

```bash
pip install mnemoverse
```

--------------------------------

### MCP Server Integration Examples

Source: https://mnemoverse.com/docs/api/rooms

Examples of passing the room domain parameter through MCP server tools for shared context.

```json
{
  "content": "Flight to Lisbon booked for Sept 12, returning Sept 19. Hotel not booked yet.",
  "domain": "xroom:room_01J8ZQ5XK7E9GVA2M4N6P8R0TC"
}
```

```json
{
  "query": "when is the Lisbon trip?",
  "domain": "xroom:room_01J8ZQ5XK7E9GVA2M4N6P8R0TC"
}
```

--------------------------------

### Automated Claude MCP setup

Source: https://mnemoverse.com

Instruct Claude to handle the MCP server installation and API key configuration automatically.

```bash
claude "Add the @mnemoverse/mcp-memory-server MCP server with env var MNEMOVERSE_API_KEY, then ask me for my key"
```

--------------------------------

### Install A2A SDK

Source: https://mnemoverse.com/docs/library/a2a-integration-howto

Install the required A2A SDK and Uvicorn server dependencies via pip.

```bash
pip install a2a-sdk uvicorn
```

--------------------------------

### Initialize Mnemoverse in Python

Source: https://mnemoverse.com/docs/llms.txt

Install the package via pip and initialize the client using your API key.

```python
pip install mnemoverse
MnemoClient(api_key="mk_live_YOUR_KEY")
```

--------------------------------

### Initialize Mnemoverse Client

Source: https://mnemoverse.com/docs/library/rescorla-wagner-agent-memory

Setup the MnemoClient using an API key to interact with the Mnemoverse service.

```python
from mnemoverse import MnemoClient
client = MnemoClient(api_key="mk_live_YOUR_KEY")
```

--------------------------------

### Quick Start with MnemoClient

Source: https://mnemoverse.com/docs/api/python-sdk

Initialize the client and perform basic memory storage, retrieval, and feedback operations.

```python
from mnemoverse import MnemoClient

client = MnemoClient(api_key="mk_live_YOUR_KEY")

# Store a memory
result = client.write(
    "Retry with exponential backoff fixed the timeout issue",
    concepts=["retry", "backoff", "timeout"],
    domain="engineering"
)
print(f"Stored: {result.stored}, ID: {result.atom_id}")

# Query memories
memories = client.read("how to handle timeouts?", top_k=5)
for item in memories.items:
    print(f"[{item.relevance:.2f}] {item.content}")

# Report outcome — the system learns what works
client.feedback(
    atom_ids=[item.atom_id for item in memories.items],
    outcome=1.0,
    query_concepts=memories.query_concepts
)
```

--------------------------------

### Gateway-exposed tool list with namespacing

Source: https://mnemoverse.com/docs/research/mcp/federated/architecture

Example of how a gateway resolves tool name collisions by applying server-name prefixes to upstream tools.

```json
// Upstream A: "github-service" · Upstream B: "local-fs"
// Gateway-exposed tools:
[
  { "name": "github-service_read_file", "description": "Read file contents from the GitHub repository..." },
  { "name": "local-fs_read_file",       "description": "Read file contents from the local workspace..." }
]
```

--------------------------------

### Install Mnemoverse MCP Server

Source: https://mnemoverse.com/docs/llms.txt

Use this command to execute the latest version of the Mnemoverse MCP server via npx.

```bash
npx -y @mnemoverse/mcp-memory-server@latest
```

--------------------------------

### Initialize and Use Mnemoverse Client

Source: https://mnemoverse.com/docs/api/use-cases/chat-extensions

Use the Python SDK to store and retrieve user context across different AI tools.

```python
from mnemoverse import MnemoClient

client = MnemoClient(api_key="mk_live_YOUR_KEY")

# Store context from a Gemini conversation
client.write(
    "User's project uses FastAPI + PostgreSQL, deployed on GCP",
    concepts=["stack", "fastapi", "gcp"]
)

# Later, in any tool — retrieve it
results = client.read("what tech stack does the user have?")
```

--------------------------------

### GET /memory/stats

Source: https://mnemoverse.com/docs/api/reference

Retrieves memory statistics for the current tenant.

```APIDOC
## GET /memory/stats

### Description
Get memory statistics for your tenant.

### Method
GET

### Endpoint
/memory/stats

### Response
#### Success Response (200)
- **total_atoms** (int) - Total atoms stored
- **episodes** (int) - Episode-type atoms
- **prototypes** (int) - Prototype atoms (from consolidation)
- **singletons** (int) - Protected singleton atoms
- **hebbian_edges** (int) - Concept-concept association edges
- **episodic_fingerprints** (int) - Number of distinct episodic-content fingerprints across stored atoms
- **domains** (string[]) - Active domain names
- **avg_valence** (float) - Average outcome valence
- **avg_importance** (float) - Average importance score
```

--------------------------------

### GET /health

Source: https://mnemoverse.com/docs/api/reference

Liveness probe to check if the service process is running.

```APIDOC
## GET /health

### Description
Liveness probe. Returns 200 as long as the process is serving. Does NOT check the database, embedding model, or any downstream.

### Method
GET

### Endpoint
/health

### Response
#### Success Response (200)
- **status** (string) - Always "ok" when the process is up.
- **database** (boolean) - Always false.
- **version** (string) - Service version.
```

--------------------------------

### GET /api/v1/memory/stats

Source: https://mnemoverse.com/docs/api/getting-started

Retrieves global statistics about the stored memory data.

```APIDOC
## GET /api/v1/memory/stats

### Description
Returns summary statistics for the user's memory store, including atom counts, edge counts, and average metrics.

### Method
GET

### Endpoint
https://core.mnemoverse.com/api/v1/memory/stats

### Response
#### Success Response (200)
- **total_atoms** (integer) - Total number of stored atoms.
- **hebbian_edges** (integer) - Total number of Hebbian edges.
- **domains** (array) - List of active domains.
```

--------------------------------

### Initialize A2A Client and Send Message

Source: https://mnemoverse.com/docs/library/a2a-integration-howto

Demonstrates the standard workflow for resolving an agent card, configuring the client, and sending a text message.

```python
import asyncio

import httpx
from a2a.client import A2ACardResolver, ClientConfig, create_client
from a2a.helpers import new_text_message
from a2a.types.a2a_pb2 import Role, SendMessageRequest

async def main():
    async with httpx.AsyncClient() as httpx_client:
        resolver = A2ACardResolver(
            httpx_client=httpx_client,
            base_url="http://127.0.0.1:9999",
        )
        card = await resolver.get_agent_card()  # async — await it

        config = ClientConfig(streaming=False)
        client = await create_client(agent=card, client_config=config)

        message = new_text_message("hello", role=Role.ROLE_USER)
        request = SendMessageRequest(message=message)

        async for chunk in client.send_message(request):
            print(chunk)

asyncio.run(main())
```

--------------------------------

### Initialize and Use Mnemoverse Memory Lifecycle

Source: https://mnemoverse.com/docs/library/hebbian-memory-for-ai-agents

Demonstrates the core write, read, and feedback loop using the MnemoClient. Requires an active API key to store memories, perform associative queries, and report outcomes for system learning.

```python
from mnemoverse import MnemoClient
client = MnemoClient(api_key="mk_live_YOUR_KEY")

# Store a memory, with the concepts it should associate
client.write(
    "Retry with exponential backoff fixed the timeout issue",
    concepts=["retry", "backoff", "timeout"],
)

# Query — Hebbian associations expand "timeout" → "backoff", "retry"
memories = client.read("how to handle timeouts?")

# Report the outcome — the system learns what works
client.feedback(
    atom_ids=[item.atom_id for item in memories.items],
    outcome=1.0,  # -1.0 (failure) to +1.0 (success)
    query_concepts=memories.query_concepts,
)
```

--------------------------------

### GET /api/v1/memory/stats

Source: https://mnemoverse.com/docs/platform/multi-tenant

Retrieves statistics including a list of active domains (tenants).

```APIDOC
## GET /api/v1/memory/stats

### Description
Retrieves statistics about memory usage, including a list of unique domains (tenants).

### Method
GET

### Endpoint
https://core.mnemoverse.com/api/v1/memory/stats

### Response
#### Success Response (200)
- **domains** (array) - A list of unique tenant domains.
```

--------------------------------

### GET /memory/stats

Source: https://mnemoverse.com/docs/openapi-gpt.yaml

Retrieve statistics regarding the current state of the memory system.

```APIDOC
## GET /memory/stats

### Description
Get memory statistics — total memories stored, domains, association count, average quality scores. Useful for understanding memory state.

### Method
GET

### Endpoint
/memory/stats
```

--------------------------------

### Get Memory Statistics

Source: https://mnemoverse.com/docs/api/python-sdk

Retrieve aggregate statistics about the stored memory database.

```python
stats = client.stats()
# stats.total_atoms: int
# stats.hebbian_edges: int
# stats.avg_valence: float
# stats.domains: list[str]
```

--------------------------------

### Configure Manual MCP Server for Editors

Source: https://mnemoverse.com/docs/api/editors

Manual configuration using an API key for Cursor, VS Code, and Windsurf. Ensure the editor is restarted after applying these changes.

```json
{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": [
        "-y",
        "@mnemoverse/mcp-memory-server@latest"
      ],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}
```

```json
{
  "servers": {
    "mnemoverse": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@mnemoverse/mcp-memory-server@latest"
      ],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": [
        "-y",
        "@mnemoverse/mcp-memory-server@latest"
      ],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}
```

--------------------------------

### Configure MCP Server

Source: https://mnemoverse.com/docs/library/memory-mcp

A minimal configuration template for adding an MCP server to a client.

```json
{
  "mcpServers": {
    "memory": {
      "command": "your-memory-server-command",
      "args": ["your-server-args"]
    }
  }
}
```

```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": { "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY" }
    }
  }
}
```

--------------------------------

### Retrieve Memory Statistics Endpoint Definition

Source: https://mnemoverse.com/docs/openapi-gpt.yaml

Defines the GET endpoint for fetching aggregate memory metrics.

```yaml
  /memory/stats:
    get:
      operationId: getMemoryStats
      summary: Memory statistics
      description: >
        Get memory statistics â€” total memories stored, domains, association count,
        average quality scores. Useful for understanding memory state.
      responses:
        '200':
          description: Statistics
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StatsResponse'
```

--------------------------------

### Minimal Agent Card Example

Source: https://mnemoverse.com/docs/library/a2a-agent-card

An illustrative JSON object representing a support-triage agent, adhering to the A2A specification.

```json
{
  "protocolVersion": "0.3.0",
  "name": "Acme Support Triage",
  "description": "Classifies inbound support tickets and drafts a first reply.",
  "url": "https://agents.acme.com/support-triage",
  "provider": { "organization": "Acme, Inc.", "url": "https://acme.com" },
  "version": "1.4.0",
  "documentationUrl": "https://acme.com/agents/support-triage",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true,
    "stateTransitionHistory": false
  },
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["application/json"],
  "skills": [
    {
      "id": "triage-ticket",
      "name": "Triage a support ticket",
      "description": "Assigns a category, priority, and suggested owner to a ticket.",
      "tags": ["support", "classification"],
      "examples": ["I was charged twice this month."],
      "inputModes": ["text/plain"],
      "outputModes": ["application/json"]
    }
  ],
  "securitySchemes": {
    "bearer": { "type": "http", "scheme": "bearer", "bearerFormat": "JWT" }
  },
  "security": [{ "bearer": [] }]
}
```
Tokens:
Raw