Personize Private

Your data never leaves your infrastructure.

Governed AI memory you run yourself. Your data, your database, your models, your cloud. One Docker image, no AWS required, nothing leaves your VPC.

Talk to us about Private See how it deploys

$docker compose -f docker-compose.gateway.yml up

Who it is for

Built for teams that cannot send data anywhere.

Healthcare

Keep patient data inside your environment. Supports your HIPAA posture, with no data egress.

Financial services

Memory and governance in your own VPC. Supports your SOC 2 and audit requirements.

Government & defense

Run fully air-gapped with Ollama or vLLM. Zero outbound network, nothing phones home.

Any regulated or data-resident team

GDPR and data-residency rules met by design: your cloud, your region, your database.

Deploy anywhere Docker runs.

The image is a plain OCI container. If it can run Docker or Kubernetes, it can run Personize Private: managed cloud, your VPC, on-prem, or fully offline.

AWS

ECS, Fargate, EKS

Azure

Container Apps, AKS

Google Cloud

Cloud Run, GKE

DigitalOcean

App Platform, DOKS

Kubernetes

Any distro, manifests included

Fly.io / Railway

Deploy the image directly

On-prem / bare VM

docker compose up

Air-gapped

Ollama / vLLM, zero outbound

No lock-in

Bring your own everything.

Your database

One Postgres holds everything: memories, governance docs, schema, the job queue, the relation graph, and quota counters. One database to run, secure, and back up.

NeonSupabase

RDS / AuroraAzure PostgresCloud SQLDigitalOceanSelf-hosted

Your models

Configure a different model per function (memorize, retrieve, generate) and per tier (basic, pro, ultra). Use a cheap model on the hot path and an expensive one only where it pays off.

OpenAI

AnthropicGoogleDeepSeekGroqTogetherMistralOllama / vLLM

Your cloud

Run it in your VPC, on-prem, or fully air-gapped. The only optional outbound call is a once-a-cycle license check. Connect only to your own Postgres and the model provider you choose.

AWSAzureGCPDigitalOceanKubernetesFly.io / RailwayOn-premOffline

gateway-llm-config.json

{
  "memorize": {
    "basic": { "provider": "openai",    "model": "gpt-4.1-nano" },
    "ultra": { "provider": "anthropic", "model": "claude-sonnet-4-6" }
  },
  "embed": { "provider": "openai", "model": "text-embedding-3-small" }
}

Your agent stack

One memory layer behind every agent you run.

Connect through the built-in MCP server or plain HTTP — the same governed, structured memory across the tools your team already uses, and your own apps. On your own Postgres and your own models.

Claude DesktopCursorLangGraphCrewAIOpenAI Agents SDKVercel AI SDKAutoGenYour own app · HTTP / SDK

MCP server, built in

Point any MCP client at /mcp with one bearer header — 13 tools for save, retrieve, search, import, and schema management. No glue code.

{ }

Memory of record, not chat logs

A governed knowledge base of your entities — typed properties, a relationship graph, documents from raw data — that every agent reads and writes. Portable across every platform, because it lives in your database.

The moat

Not just memory. Governed memory.

Running pgvector yourself gives you a place to store text. Personize adds the layer that decides how your agents should behave with that text.

Your policies, applied on every action

Brand voice, compliance rules, and playbooks are retrieved and applied on every agent action through SmartContext, not pasted into a prompt and hoped for.

One call, full context

Unified retrieval returns memory, governance docs, and the entity graph together in a single call, in scout, brief, expand, filter, or fetch modes.

Consistent agents at scale

Every agent reads from the same governed source, so behaviour stays consistent across tools, teammates, and replicas.

A raw vector DB

Remembers text. You still write the rules into every prompt, by hand, in every tool.

Personize Private

Enforces how the agent should behave with that text, consistently, on every action.

Scales from a laptop to a cluster.

Personize Private is stateless: all state lives in your Postgres, so you scale by adding replicas. The async job queue uses Postgres row locking, so every job runs exactly once no matter how many replicas, and per-plan quotas are counted globally.

Scenario	Shape	What it handles
Evaluate / small team	1 container (about 512 MB to 1 GB) + a Neon free tier	Thousands of memories, interactive use
Production team	2 replicas behind a load balancer + a managed Postgres	Steady write and retrieve traffic, high availability
High volume	Kubernetes HPA 2 to 10 replicas + a larger Postgres	Bursty load; Postgres is the throughput anchor

Lower total cost

No credit markup. The cost levers are yours.

What you pay, hosted

Model usage

+ credit markup

What you pay, Private

no markup

Model usage, at cost

↓ go lower: route a model per function, right-size per tier, or run fully local.

You pay for the model. Not a markup.

You pay your model provider directly, at their list price, with no per-token credit markup on top. From there the cost levers are yours: a cheap model on the hot path, a frontier model only where it pays, or fully local inference.

Illustrative cost shape, not to scale. Your numbers depend on volume and model choice.

Pay your provider directly

Bring your own key and pay list price. Personize Private adds no per-token credit markup.

Route a model per function

Memorize, retrieve, and generate can each use a different model. Pay for quality only where it changes the answer.

Right-size every call

A nano-class model on the hot path, a frontier model only for the top tier. You control the mix per tier.

Go to zero on inference

Point the gateway at Ollama or vLLM for fully local, zero-marginal-cost models and zero data egress.

Small footprint

A stateless container plus a bounded job queue runs on a cheap VM. Scale out only for throughput.

Illustrative

A small team can run Personize Private on a Neon free tier, a 1 GB container, and their own OpenAI key, paying only metered model usage, with no platform fees and no credit markup. Your numbers depend on volume and model choice.

The full product

Everything, self-hosted. Not a sample.

Personize Private is the full memory and governance engine, not a trimmed preview.

Memory extraction

POST /memory/save turns raw text about a person, company, or deal into structured memories and properties, using your own LLM. Steer each call with a per-call extraction focus.

Bulk and import

Load a CRM page with /memory/save/batch, or hand /memory/import raw rows plus a column mapping for async ingest at any scale. Built for CRM sync, CSV, and backfill.

Structured upsert

Write entity records with explicit property values and no LLM, for syncing structured data straight from code.

Unified retrieval

One /memory/retrieve call returns memories, governance documents, and the graph in scout, brief, expand, filter, or fetch modes.

Knowledge graph

Relationships between records, three ways: declared by the caller, inferred from extracted properties, or surfaced by the LLM from the text itself.

Schema you control

Install a starter kit, or live-manage the schema: entity types, collections, relation types, document types, and tags, all over REST or MCP.

Scheduling

Recurring prompts with rate(...) and cron(...), cluster-safe across replicas.

MCP server

Connect Claude Desktop or Cursor directly, 13 tools, with a single config change.

Offline-enforced plans

Your purchased plan's monthly limits are enforced inside the image, offline, via a signed license key.

Cloud or Private, one API.

Start on Cloud, move to Private without a rewrite. Identical SDK and endpoints; migration is a baseUrl and a database, not a project.

	Personize Cloud	Personize Private
Who runs it	Personize (managed)	You, any cloud, on-prem, or offline
Where data lives	Personize cloud	Your own Postgres
Models	Managed	Yours, or fully offline
Cost shape	Credit-based	Direct LLM cost, no credit markup
Compliance	Shared infra	Your VPC, your data residency

Get started

Running in your own VPC in minutes.

No AWS account, no proprietary services. Three steps from a pull to a governed memory API serving on :3000.

Pull the image

One multi-arch OCI container. Run it with the bundled compose, or drop it into your own Kubernetes manifests.

docker pull ghcr.io/personizeai/personize-gateway:stable

Point it at your Postgres and model

Your database URL, a provider key (or a local Ollama/vLLM URL), and a bearer token for the API. Migrations run on boot.

DATABASE_URL=postgres://user:pass@your-db:5432/personize
OPENROUTER_API_KEY=sk-...        # or OPENAI / a local LLM_BASE_URL
GATEWAY_API_KEY=<your-bearer-token>

Enable it with your plan

Connected mode reads your plan's limits from your existing Personize key — a free plan works. Air-gapped boxes drop in a signed offline license instead.

PERSONIZE_API_KEY=sk_live_...
PERSONIZE_BASE_URL=https://agent.personize.ai

Get a key and onboarding

ghcr.io/personizeai/personize-gateway:stable · Postgres + pgvector · 13 MCP tools

Governed AI memory you actually own.

Run it in your VPC, on-prem, or fully offline. Your data, your database, your models. Talk to us about Personize Private.

Talk to us about Private Explore the platform