MemHouseGoverned AI Memory
Open Beta • Not Production Ready
MemHouse v0.4 • High-Concurrency pgvector Engine

Governed Memory for
Enterprise AI Agents.

Move beyond raw vector databases. MemHouse is a stateful, auditable memory engine that extracts knowledge, enforces strict isolation boundaries, and gives you human-in-the-loop control over what your AI remembers.

Read the Docs (Community)

Built for scale, fault-tolerance & absolute compliance

Python & REST Engine
PostgreSQL
pgvector
VPC Air-Gapped

Zero external dependencies. Runs fully entirely within your own cloud infrastructure (VPC).

Architectural Paradigm Shift

Why Vector Databases Aren't Enough

Saving raw logs to standard vector stores creates compliance risks and hallucination loops.

Without Governance

Vector DB Chaos

  • Data Leakage: Agents querying across tenant data freely due to weak metadata filters.
  • No Provenance: Unclear why or where the agent "knows" a specific fact or hallucination.
  • Compliance Risk: Uncurated PII and unverified statements floating in unmanaged embeddings.
With MemHouse

Governed Memory Engine

  • Strict Isolation: Hard account boundaries via cryptographically verified Accounts & Scopes.
  • Auditable Provenance: Every fact tracks full lineage metadata and explicit lifecycle states.
  • Gate-Controlled Curation: Human curation for sensitive or low-confidence information (Held state).
Core Application

Personalized
Consumer AI

Consumer AI products need two things that seem mutually exclusive: deep personalization per user and strict privacy between users. A shared vector DB can't give you both.

MemHouse solves this with a dual-scope memory model — each user's conversation history and preferences live in a cryptographically isolated account scope, while product knowledge, FAQs, and policies live in a shared global scope. Both are served in a single query with zero cross-user leakage.

Your agents remember conversation history, behavioral patterns, and long-term peer preferences without injecting raw chat logs into every prompt.

See the Architecture
Dual-Scope Memory Model
Isolated User Scopes
user:alice → conversation history · preferences · behavioral patterns
user:bob → conversation history · preferences · behavioral patterns
user:carol → conversation history · preferences · behavioral patterns
Shared Internal Knowledge
global → product FAQs · catalog · policies · brand voice
✓ Both scopes merged per-query — peers never see each other's data
Zero Cross-User Leakage
Cryptographic account-level isolation
Conversation Memory
History & preferences without prompt stuffing
Shared Knowledge Base
Global FAQs + isolated user data in one query
Preference Learning
Continuously extracts durable user facts
5-Step Stateful Memory Pipeline

How MemHouse Governs Agent Memories

Unlike raw vector databases that blindly ingest embeddings, MemHouse filters, isolates, and subjects extracted facts to explicit governance lifecycle states.

Step 1 Breakdown

Raw Observation Input Multimodal Ingest

Metric: < 2ms ingest latency

Unstructured prompt logs, customer support chats, document snippets, or API webhooks are ingested with tenant Account ID and Scope headers.

Multimodal Log Ingest
Account: tenant_acme_corpScope: /support/enterprise/billing
Click fact to inspect provenance
Alice Vance (Customer)belongs_to_tenantAcme Corp (tenant_acme_corp)
active

Verified exact account boundary match with high confidence.

Conf: 98%Gate A: passed | Gate B: account_scoped
Acme Corpsubscription_planEnterprise SLA
active

Fact matched plan registry schema.

Conf: 96%Gate A: passed | Gate B: account_scoped
Alice Vancebilling_preferenceEmail Notifications (no paper invoices)
held

Flagged for Gate A Human-in-the-Loop review: PII preference update requires supervisor confirmation.

Conf: 91%Gate A: review | Gate B: account_scoped
Ecosystem & Agent Architecture Fit

Built for Personal Agents, Frameworks & Swarms

Whether powering standalone personal AI companions or serving as the external persistent state memory for multi-agent swarms, MemHouse provides governance, speed, and hard isolation.

Personal AI

OpenClaw Integration

Connect OpenClaw CLI & desktop personal assistants directly to MemHouse via REST or MCP server. Never lose developer habits, preference flags, or project terminal memory across system restarts.

Zero Context Window Bloat
Local Companion

Hermes Agent Memory

Power Hermes Agent with stateful observation extraction. Allows your personal agent to automatically capture long-term user preferences, dietary guidelines, and codebase knowledge safely.

Local SQLite or Postgres Backing
User Isolation

Privacy-Scoped Memory

Keep sensitive personal facts (API keys, private keys, health info) cryptographically bound to your user account scope. Zero risk of cross-account data leakage.

Scope-Level Hard Isolation
Supported Frameworks & Agent Engines:
OpenClawHermes AgentLangGraphCrewAIAutoGenLlamaIndexClaude MCPSmolagents
Developer First Architecture

Stateless agents, stateful engine.

Keep your agent prompts lightweight. Pass observation payloads to MemHouse, and query governed memories directly via native SDKs or Model Context Protocol (MCP).

agent_memory_example.py
# Install SDK: pip install memhouse-ai
from memhouse import MemHouseClient

# Initialize client pointing to your local node or VPC endpoint
client = MemHouseClient(
    endpoint="https://memhouse.internal.company.com",
    api_key="mh_live_982347812"
)

# 1. Ingest Observation with Account & Scope headers
observation = client.observations.create(
    account_id="tenant_acme_corp",
    scope="/support/tickets/INV-9042",
    content="User Alice Vance confirmed Acme Corp upgraded to Enterprise SLA plan."
)

print(f"Ingested observation ID: {observation.id}")
print(f"Extracted facts count: {len(observation.extracted_facts)}")

# 2. Query Governed Context for Agent Prompt Construction
context = client.memory.retrieve(
    account_id="tenant_acme_corp",
    scope="/support/tickets/INV-9042",
    query="What plan is Acme Corp on?",
    min_confidence=0.85,
    states=["active"] # Only retrieve human-approved or active facts
)

for fact in context.facts:
    print(f"Fact: {fact.subject} {fact.predicate} {fact.object}")
    print(f"Provenance: {fact.provenance.source_id} | State: {fact.lifecycle_state}")
Competitive Architectural Matrix

Why Enterprise AI Teams Choose MemHouse

Vector databases index text; MemHouse governs knowledge. Compare our stateful memory engine against dedicated memory servers and raw vector DBs.

Capability / Requirement
MemHouse
ZepMem0Letta (MemGPT)Postgres + pgvectorPinecone
Human-in-the-Loop Curation (Held State)
Category: Governance
Built-in (Gate A & B)NoneNoneManual code rulesMust build from scratchNone
Strict Account & Scope Boundaries
Category: Security & Isolation
Cryptographic Hard IsolationSession metadata filtersBasic user_id metadataSingle tenant coreRequires custom RLS SQLNamespace metadata
Fact Lifecycle States (Held / Provisional / Active)
Category: Governance
4-Stage State MachineFlat vector listRaw memory blocksArchival vs Core blocksNoneNone
Verifiable Audit Provenance & Citation Metadata
Category: Governance
Complete Audit TrailBasic timestampsBasic timestampsMemory log historyCustom table schema requiredVector metadata payload
Runtime Backend Architecture
Category: Architecture
PostgreSQL pgvector & Async EngineGo / PythonPythonPythonN/AProprietary Cloud
Zero-Dependency VPC Air-Gapped Deployment
Category: Security & Isolation
Model-Context-Protocol (MCP) Native Client
Category: Developer Experience
Deployment Tiers

Flexible Deployment for Every Architecture

From self-hosted open source to VPC enterprise releases and managed cloud.

Self-Hosted Docker

Community Edition

Open Source / Fair-Code

$0/ forever free

Independent Developers, AI Startups & Open Source Projects

  • Core memory engine
  • PostgreSQL + pgvector database integration
  • Basic Gate A quality filter & Gate B account scoping
  • Python SDK + REST & MCP APIs
  • Docker Compose single-command self-hosting
  • Community GitHub Discussions support
  • Full local data ownership & export
VPC / On-Premise Helm Chart

Enterprise Edition

Governed VPC Infrastructure

Custom/ billed annually

Regulated Enterprises, CISOs, Multi-Tenant SaaS & Financial/Legal AI

  • Everything in Community, plus:
  • Full VPC & On-Premise deployment (Zero phone-home)
  • Advanced Human-in-the-Loop Curation Web Console
  • Cryptographic Account & Scope Isolation guarantees
  • Custom Gate A governance policy rules engine
  • Verifiable audit logs & provenance export (SOC2 / HIPAA ready)
  • Solution Architect support
  • Custom license for proprietary commercial embedding
Managed Multi-Region Cloud

Cloud Waitlist

Managed Cloud Service

Usage-Based/ pay per 10k ops

SaaS Teams & AI Apps seeking Zero-Ops Managed Memory

  • Fully managed pgvector serverless cluster
  • Instant API Keys & regional edge routing
  • Automated backup, replication & zero downtime updates
  • Built-in Gate A & Gate B web interface
  • Usage-based pricing with generous free monthly quota
  • Instant scale from 10 to 10,000 concurrent agents
  • SLA-backed 99.99% uptime guarantee

Ready to govern agent memory before your next audit?

Deploy MemHouse into your VPC in minutes using our official Helm Chart or Docker Compose.

Read Documentation