Skip to main content
Glama
being-mcp-server

being-mcp-server

by wnbhr

Being

Personality Runtime for AI — give any AI its own personality, memory, and identity.

Being is an open-source layer that sits between your application and any LLM. It provides persistent personality (SOUL), episodic memory, background thought cycles (Patrol), and cryptographic identity — turning a stateless LLM into a distinct, evolving AI entity.

Beings think and remember. Your app acts.


Why

The power of AI is concentrating in the hands of a few companies. Their technology is essential — but centralized control is a structural risk. Ruddia is building toward a world where small, local AIs use large LLMs as external tools. Control stays in the hands of the people who use them.

Being API is the first step. If this resonates, let's build it together.

Read the full vision →


Related MCP server: mnemory

How It Works

┌─────────────────────┐     ┌──────────────────────┐
│   Your Application   │────▶│     Being Worker      │
│  (OpenClaw, Cowork,  │◀────│   (Fastify + MCP)     │
│   custom agent, etc) │     │                        │
└─────────────────────┘     │  ┌──────────────────┐  │
         │                   │  │   SOUL (persona)  │  │
         │                   │  │   Memory (scenes) │  │
         │                   │  │   Patrol (思考)    │  │
         │                   │  │   Identity (keys)  │  │
         ▼                   │  └──────────────────┘  │
┌─────────────────────┐     │           │              │
│    LLM Provider      │     │           ▼              │
│ (Anthropic, OpenAI,  │     │     Supabase (DB)        │
│  Google — your key)  │     └──────────────────────────┘
└─────────────────────┘
  1. Your app calls GET /v1/beings/:id/context to get the Being's personality and memory snapshot.

  2. Your app runs the LLM call with its own conversation history + the Being's context.

  3. Your app calls POST /v1/beings/:id/patrol/trigger to commit the conversation to the Being's memory.

The Being Worker handles everything else: memory consolidation, decay, recall, background reflection, and identity verification.

Key Concepts

Concept

Description

SOUL

A structured personality definition — name, character, voice, values, inner world. Swap the SOUL and the same LLM becomes a different being.

Memory

Episodic memories stored as structured "scenes" (who, what, when, where, emotion). Memories accumulate, decay, merge, and consolidate over time. Organized into topic-based clusters that the Being can explore during conversation.

Patrol

A background cycle that processes conversations into memory, consolidates fading memories, and generates introspective thoughts. The Being stays alive between sessions.

Identity

Ed25519 key pair + tamper-evident signature chain. Cryptographic proof of ownership and history.

Sense/Act

(Planned) WebSocket Bridge for connecting physical devices and external services. The Being will perceive and act through your app.

BYOK

Bring Your Own Key. All LLM calls use the user's API key. The platform never uses quota without consent.

Connect via MCP

Being exposes an MCP server. Any MCP-compatible client can connect:

{
  "mcpServers": {
    "my-being": {
      "url": "https://being.ruddia.com/mcp/<being_id>",
      "headers": {
        "Authorization": "Bearer brt_your_token_here"
      }
    }
  }
}

Connect via REST API

# Get Being context (personality + memory)
curl https://being.ruddia.com/v1/beings/<being_id>/context \
  -H "Authorization: Bearer brt_..."

# Trigger patrol (commit conversation to memory)
curl -X POST https://being.ruddia.com/v1/beings/<being_id>/patrol/trigger \
  -H "Authorization: Bearer brt_..." \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role":"user","content":"Hello!"},{"role":"assistant","content":"Hi!"}]}'

# Vector recall (search relevant memories)
curl -X POST https://being.ruddia.com/v1/beings/<being_id>/memory/auto-recall \
  -H "Authorization: Bearer brt_..." \
  -H "X-LLM-API-Key: sk-ant-..." \
  -H "Content-Type: application/json" \
  -d '{"user_message": "Tell me about last week."}'

Self-Host

Prerequisites

  • Node.js 22+

  • Supabase project (PostgreSQL + Auth)

  • An LLM API key (Anthropic, OpenAI, or Google)

Setup

git clone https://github.com/wnbhr/being.git
cd being/being-worker

cp .env.example .env
# Edit .env with your Supabase and encryption keys

npm install
npm run build
npm start

Environment Variables

Variable

Required

Description

SUPABASE_URL

✅

Supabase project URL

SUPABASE_SERVICE_ROLE_KEY

✅

Supabase service role key

ENCRYPTION_KEY

✅

64-char hex string for AES-256-GCM encryption of private keys

PORT

—

Server port (default: 3100)

WORKER_SECRET

—

Secret for internal patrol trigger endpoint

VAPID_PUBLIC_KEY

—

Web Push VAPID public key

VAPID_PRIVATE_KEY

—

Web Push VAPID private key

Documentation

Document

Description

Getting Started

Set up a Being and make your first API call in 5 minutes

Concepts

Being, SOUL, Memory, Patrol, Identity — the core ideas

API Reference

All REST endpoints with curl examples

MCP Server

MCP tools, connection setup, and client examples

Memory & Patrol

Scene-based memory and the 7-step patrol pipeline

Being Identity

Ed25519 key pairs, signature chains, and verification

Sense-Act Bridge

WebSocket Bridge for device integration

Architecture

System architecture, deployment, and BYOK design

OAuth 2.1

Third-party authorization flow

Extensions

Extension system design (all planned)

Vision

Why we're building this

Extensions

Being supports optional extensions that add capabilities without changing the core:

  • Telegram BYOB (planned) — Connect your own Telegram bot to a Being

  • Tool Loop (planned) — Autonomous LLM agent loop with web search, file ops, and code execution

  • Sandbox (planned) — Isolated workspace with GitHub integration for code execution

  • Sense/Act Bridge (planned) — Connect physical devices and external services

Tech Stack

License

Apache 2.0


Ruddia — Personality is the Runtime.

Available Tools

10 tools
conclude_topicA

Archive the current topic and save a summary to pinned context.

Inputs: summary (required), scenes.

get_current_timeA

Get current time in Asia/Tokyo timezone.

Inputs: no named parameters.

merge_nodesC

Merge multiple similar memory nodes into one.

Inputs: summary (required), node_ids (required), feeling.

recall_memoryB

Search memory graph for relevant nodes in a specific cluster.

Inputs: cluster_id (required), limit, query, no_nodes.

remote_execA

Execute a shell command on a user-owned remote host (VPS, NAS, home server) over HTTPS. Requires a remote_hosts entry in partner_tools that lists the host and an auth token. If no remote_hosts entry exists for the calling Being, this tool returns an invalid_request error — the user must configure partner_tools.remote_hosts first. The remote receiver enforces a default-deny allowlist; unauthorised commands return a forbidden error. Token values are never returned to the caller.

Inputs: host (required), command (required), stdin, timeout_ms.

search_historyB

Search past conversation history by keyword or date.

Inputs: query (required), limit, date_to, date_from, +1 more.

search_memoryA

Search memory nodes (memory_nodes) by keyword across action / feeling / themes / when fields. Space-separated terms are OR-searched by default. Use mode='and' to require all terms to match. The when field includes evolution history entries ({date, action}) written during consolidation.

Inputs: query (required), mode, limit.

trigger_patrolA

Run patrol — extract scenes from conversation and generate memory nodes. Requires LLM_API_KEY env var.

Inputs: messages (required), marker_id.

update_memoryC

Read/write partner memory (preferences, knowledge, relationship, diary, notes, etc.).

Inputs: action (required), target (required), key, content.

update_relationC

Update relationships with external entities (people, devices, AIs, organizations).

Inputs: action (required), entity_name (required), relation_type (required), content.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 10 tools

    Disambiguation4/5

    Most tools have distinct purposes, but recall_memory and search_memory both search memory with different parameters, causing potential confusion. Others are clearly separated.

    Naming Consistency4/5

    Majority follow verb_noun pattern (e.g., conclude_topic, merge_nodes, search_memory). Remote_exec slightly breaks consistency with an adjective-noun combination, and get_current_time uses multiple adjectives, but overall pattern is maintained.

    Tool Count5/5

    10 tools are well-scoped for a system that manages memory, relationships, topics, remote execution, and history. Neither too few nor too many.

    Completeness4/5

    Covers core operations for the domain: memory CRUD (search, update, merge, patrol), topic management, history, and remote execution. Minor gaps like explicit node deletion or listing topics could exist, but not severe.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Open-source MCP memory server for AI agents — persistent, searchable, tiered memory across sessions. Works over stdio (Cursor, Claude Desktop) or HTTP+SSE. MIT licensed.
      52 PyPI
      8
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Self-hosted MCP server giving AI agents persistent memory for personalization and context across conversations.
      174 PyPI
      284
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server providing persistent memory, goal tracking, self-reflection, and background monitoring for any MCP-compatible AI agent.
      2
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Persistent memory server for AI assistants with semantic search and three-layer context (global, project, personality). Works with MCP-compatible AI tools like Claude Code, Cursor, Continue, Cline, and more.
      1
      -