Senior developers get better AI results — not because of better prompts, but because of accumulated operational know-how. Monet captures that intelligence as shared memory, so your entire team benefits from the same AI expertise.

Monet is an open-source, multi-tenant memory platform for AI agents. It gives your agent team a shared memory layer that persists across sessions, agents, and team members — with native MCP support and true tenant isolation.

Why Monet?

Key Features

• 🧠 Shared Memory for Agent Teams — Agents read and write to a shared memory layer scoped by group, user, or private access
• 🔌 Native MCP Support — Connect any MCP-compatible agent with a single endpoint: /mcp/:tenantSlug
• 🏢 True Multi-Tenant Isolation — PostgreSQL schema-level isolation per tenant, ready for SaaS and MSP use cases
• 📊 Dashboard UI — Setup, tenant administration, and memory inspection at a glance
• 🔍 Semantic Search — pgvector-powered embedding search with automatic enrichment (summaries, tags, vectors)
• 📋 Audit Trail — Append-only audit logs with DB-level protection for compliance and observability
• 🏠 Self-Hosted — Run on your infrastructure. No cloud lock-in. Your data stays yours.

Memory That Works Like Your Team

Monet organizes memories by type and scope, matching how teams actually think:

Memory Types: decision · pattern · issue · preference · fact · procedure

Memory Scopes:

┌─────────────────────────────────────────────┐
│                  Tenant                      │
│                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ Agent A   │  │ Agent B   │  │ Agent C   │  │
│  │ (Support) │  │ (Support) │  │ (Billing) │  │
│  └─────┬─────┘  └─────┬─────┘  └─────┬─────┘  │
│        │              │              │         │
│        ▼              ▼              ▼         │
│  ┌─────────────────────────────────────────┐  │
│  │           Shared Memory Layer           │  │
│  │                                         │  │
│  │  🔵 group scope   → visible to all     │  │
│  │  🟡 user scope    → per-user context    │  │
│  │  🔴 private scope → agent-only          │  │
│  └─────────────────────────────────────────┘  │
└─────────────────────────────────────────────┘

Getting Started

Prerequisites

• Node.js 20+
• pnpm
• Docker (for local infrastructure)

Quick Start (Local)

git clone https://github.com/team-monet/monet.git
cd monet
pnpm install
cp .env.local-dev.example .env.local-dev
pnpm local:up

Then follow the full local setup guide:

• Local Development Guide →

Connect Your Agent (MCP)

Once Monet is running, connect any MCP-compatible agent:

{
  "mcpServers": {
    "monet": {
      "url": "http://localhost:3301/mcp/your-tenant",
      "headers": {
        "Authorization": "Bearer your-agent-api-key"
      }
    }
  }
}

Your agent now has access to these memory tools:

Quick API Example

# Store a memory
curl -X POST http://localhost:3301/api/tenants/acme/memories \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Always use pagination for list endpoints. Limit default is 50.",
    "memoryType": "pattern",
    "memoryScope": "group",
    "tags": ["api", "best-practice", "pagination"]
  }'

# Search memories
curl "http://localhost:3301/api/tenants/acme/memories?query=pagination+best+practice&limit=5" \
  -H "Authorization: Bearer $API_KEY"

Architecture

Monet runs as a straightforward service stack designed for self-hosted deployment:

┌─────────────┐  ┌──────────────┐
│  Dashboard   │  │  API Service  │── /api/tenants/:slug/...
│  (Next.js)   │  │              │── /mcp/:slug
└─────────────┘  └──────┬───────┘
                        │
        ┌───────────────┼───────────────┐
        │               │               │
   ┌────▼────┐   ┌──────▼──────┐   ┌───▼───┐
   │ PostgreSQL │  │  OIDC Auth  │   │ Enrich │
   │ + pgvector │  │ (Keycloak)  │   │ Pipeline│
   └───────────┘  └─────────────┘   └────────┘

Core design decisions:

• Tenant-qualified routing — every request is scoped to a tenant via URL path
• Schema isolation — per-tenant PostgreSQL schemas (tenant_<id>) with SET LOCAL search_path
• MCP as a first-class citizen — dedicated endpoint, session lifecycle management, tool schema registry
• Enrichment pipeline — automatic summary, tag extraction, and vector embedding on every memory write

Read the full architecture overview: docs/architecture.md →

Production Deployment

Monet is designed for single-host Docker Compose deployment — no Kubernetes required:

cp .env.runtime.example .env.runtime
docker compose -f docker-compose.runtime.yml up -d

• Production Deployment Guide →
• Backup and Restore →
• Migration and Upgrade →

Documentation

Contributing

We welcome contributions! Start here:

• CONTRIBUTING.md →

Security

Please report vulnerabilities through private GitHub advisories (not public issues/PRs):

• SECURITY.md →

License

Monet is licensed under the Apache License 2.0. See LICENSE.