Frequently asked questions

Cited answers to the questions we are asked most often about GoodMem.

Last reviewed

What GoodMem does, and when you need it

Understand what GoodMem is, what it stores, and when to use something else.

What is GoodMem?

GoodMem is a memory server for AI agents that stores documents, conversation history, and any other knowledge an agent needs. You can self-host it or use it as the managed GoodMem Cloud service.

Your application calls GoodMem to store content and to retrieve relevant passages when an agent needs them. GoodMem extracts, chunks, embeds, and indexes what you store, checks permissions on retrieval, and works with any model.

What is a "memory" in GoodMem?

A memory is any piece of content you store in GoodMem along with its content type and optional metadata. It can be a PDF or Office document, a conversation transcript, a single chat message, a note, or a fact your agent decided to save. GoodMem does not extract facts from your content on its own; it stores what you give it.

GoodMem keeps the original content, extracts its text, splits it into chunks, and embeds each chunk. The space sets the default chunking rules, and an individual memory can override them or turn chunking off. Retrieval returns chunks that each cite the source memory and the position they came from. A long document produces many chunks, so storage grows with the number of chunks, not the number of memories.

When do I actually need a memory layer?

You need a memory layer when your agents require context that outlives a single request, for example to remember a user or past conversations across sessions, or when several agents, users, or teams share that context under different permissions.

In practice, the need shows up when agents re-read the same source material on every run and growing context windows become your main cost. It also shows up when knowledge has to be scoped per customer or per team and you need to audit afterwards what was retrieved.

When is a plain vector database enough, and when should I not use GoodMem?

A plain vector database is enough when you have one corpus, one embedding model, one trust boundary, and a document pipeline you are happy to own. If you are embedding clean text you already have and serving it to a single application, pgvector or a dedicated vector store will do the job with less to run.

Use GoodMem when you need several embedders combined and weighted, real document extraction for PDF and Office formats with page images, permissions across many users and agents, a record of what was retrieved, or memory that carries across an agent's conversations.

What does GoodMem not do?

GoodMem does not extract facts from your content or summarize it when you store it, and it does not resolve contradictions between an older and a newer version of the same fact. It stores what you give it, and it does not expire memories on a timer or update a memory in place.

Who builds GoodMem?

GoodMem is built and operated by PAIR Systems, Inc., a Delaware corporation founded in late 2024 and backed by Silicon Valley venture firms. GoodMem is the product; PAIR Systems is the entity you contract with.

PAIR Systems holds an ISO/IEC 27001 certification, has completed a SOC 2 Type II audit, and publishes its policies and security documentation through its trust center. Incorta runs GoodMem in production; further references and security evidence are available under NDA as part of a review.

Memory, retrieval, and the document lifecycle

How you add content to GoodMem and get it back out.

How does retrieval work?

Retrieval runs a query through every embedder registered on the space, combines the results, and optionally reranks and post-processes them before returning chunks with relevance scores and citations.

A space can carry both dense and sparse embedders, so lexical and semantic matching run together and their scores are combined with per-embedder weights you control. You can constrain results with metadata filters, cap them by count or relevance threshold, and tune the search parameters of the underlying index for each request.

What document formats does GoodMem ingest, and how is content chunked?

GoodMem ingests PDF, Word, PowerPoint, Excel (.xlsx), RTF, and OpenDocument files, along with plain text, Markdown, HTML, CSV, XML, and JSON, and splits extracted text into configurable chunks. Text extraction is layout-aware, and for PDF, Word, PowerPoint, and Excel files GoodMem can optionally extract page images that you fetch on demand to support citations. OCR does not run automatically when you store a memory; for scanned PDFs and images, you run the separate OCR add-on first and store the text it produces.

The space sets default chunking settings for chunk size, overlap, and separators, and a single memory can override them. Ingestion is asynchronous: a memory is created immediately and shows a processing status until its chunks are indexed and searchable.

How do I correct a memory when the underlying fact changes?

You correct a memory by deleting it and creating a replacement, and you can reuse the same memory ID for the replacement. GoodMem has no in-place update operation, and a memory's metadata is fixed when the memory is created and cannot be edited.

The replacement does not show up in results until it finishes processing. If you delete first, the fact is briefly missing; if you create first, both versions can briefly match. Pick whichever your agent tolerates better.

What stops an agent from retrieving a stale or superseded fact?

Nothing in GoodMem automatically resolves a contradiction between two memories — if both an old and a new version of a fact are stored in the same space, retrieval can return both and the model decides what to do with them.

The controls you have are deletion, metadata filters that scope a query to the material you consider current, and an optional chronological re-sort of results. If correctness depends on recency, treat superseding as an explicit step in your ingestion pipeline rather than something retrieval will infer.

What happens when I delete a memory?

Deleting a memory removes it from the active GoodMem database and search indexes, including the chunks derived from it and their dense and sparse index entries. GoodMem does not provide a soft-delete or recycle bin.

Copies may remain in database backups or separately retained retrieval records until they age out under the retention schedules that the operator sets.

You can delete memories individually or in batches, including by metadata filter. Retrieval logs, where enabled, are governed separately by their own retention: they are written to daily partitions, so operators expire them by dropping partitions on whatever schedule their retention policy requires.

Is there a TTL or automatic expiry on memories?

There is no TTL, expiry, or decay on a memory today. A memory persists until something deletes it, so a space only grows unless you manage retention yourself.

The supported pattern is to record your own retention marker in a memory's metadata at ingest, then run a scheduled batch delete filtered on that marker. API keys are separate: those do support validity windows and expiry.

What happens when I want to change embedding models?

Changing the embedding model for already-indexed content means creating a new space with the new embedder and re-ingesting into it. GoodMem rejects changes to an embedder's model identifier or dimensionality while a space still uses it, because existing vectors would no longer be comparable.

There is no automatic re-embedding or backfill job. GoodMem stores the original content and lets you download it, so re-ingesting does not require going back to the source system, though it is still a re-ingest and you should plan for the embedding cost and the time it takes.

SDKs, integrations, and agent workflows

The SDKs, APIs, and agent frameworks GoodMem plugs into.

Which languages have official SDKs?

GoodMem publishes first-party SDKs for Python, TypeScript, Java, Go, .NET, and Rust, plus an MCP server. All of them are generated from a single shared API description, so each one exposes the same core API.

The SDKs are open source under the Apache-2.0 license. Python, TypeScript, Java, Go, and .NET packages are available from their language registries; the Rust SDK is available from source. The GoodMem server itself is separately licensed — see the licensing section below.

Does GoodMem expose REST or gRPC?

GoodMem exposes both REST and gRPC with the same operations, and both authenticate with an API key in the `x-api-key` header. Pick whichever protocol fits your stack.

The published SDKs are the easiest path for most people. If you want to generate your own gRPC stubs or explore the API with grpcurl, gRPC server reflection is enabled on every GoodMem server and does not require an API key, and the docs publish a full gRPC reference.

Which agent frameworks does GoodMem integrate with?

GoodMem integrates with LangChain, LangGraph, LlamaIndex, CrewAI, Google ADK, Microsoft Agent Framework, Semantic Kernel, AutoGen, Spring AI, LangChain4j, DSPy, Genkit, CAMEL-AI, and NLWeb, plus the workflow builders n8n and Activepieces.

Most integrations give you the framework's native retriever (or knowledge/context) class plus tools the model can call to save and search memories. Google ADK and Microsoft Agent Framework can also save and recall memory automatically on each turn, without the model having to call a tool. AutoGen recalls memory automatically each turn by injecting retrieved passages into context, while saving is an explicit `add()` call.

Is there an MCP server?

Yes, GoodMem ships an MCP server that exposes its operations to compatible MCP clients, along with packaged plugins for Claude Code, Codex, and ChatGPT. With the MCP server or the Claude Code plugin, you can set up embedders and spaces, ingest documents, and run retrieval from a conversation with your coding agent without writing integration code.

Which embedding, reranking, and generation providers can I use?

GoodMem calls embedding, reranking, and generation models as registered endpoints rather than bundling a fixed model, so you register the providers you want to use and supply your own credentials.

Both hosted commercial providers and self-hosted inference servers are supported, and the set of supported providers changes as models ship. The endpoint registration guide has the current list, and for each provider it gives the base URL and explains how paths are handled.

Are there connectors for SharePoint, S3, Confluence, or other source systems?

GoodMem does not include packaged connectors for systems like SharePoint, S3, or Confluence; most deployments load content through the ingestion API from their own pipeline. You can also use the n8n and Activepieces integrations to pull content from the source systems those platforms connect to (for example Google Drive), and there is an open-source email ingester for .eml, mbox, and Maildir.

We have built source-system connectors for individual customers. If a connector is on your critical path, talk to us so we can scope it.

Can I run GoodMem without sending content to a third-party model provider?

Yes, GoodMem supports self-hosted endpoints for embedding, reranking, and generation (for example vLLM, Ollama, llama.cpp, or any OpenAI-compatible server), and the OCR add-on can also run in your environment, so a deployment can run without content leaving your network.

This is a configuration choice, not an enforced mode: if an operator registers an external provider, content sent to that provider leaves your network. If content must never leave a boundary, register only self-hosted endpoints, run the OCR add-on yourself and point the server at it, and control who has permission to register new endpoints.

Deployment and operations

Running GoodMem yourself versus letting GoodMem Cloud handle it for you.

How can I deploy GoodMem?

There are two deployment models: GoodMem Cloud, a managed service where each instance gets its own GoodMem server and its own database, and self-hosting, where you run the server yourself under the free binary license.

For self-hosting, you can use the Docker Compose installer, one-command deploy scripts for Railway, Fly.io, AWS Lightsail, and Hetzner, or a Google Cloud Marketplace VM image. There is no Helm chart or Kubernetes operator today; teams on Kubernetes write their own manifests against the documented ports and health endpoints.

What does self-hosting require?

Self-hosting requires a container runtime, a PostgreSQL database with the pgvector extension, and a disk-backed scratch volume for document processing. There is no separate vector database, message broker, or object store to run. Depending on what you use, GoodMem calls the embedding, reranking, and generation endpoints you register, and the optional OCR add-on; these can be self-hosted or third-party.

The server is a Java service on a distroless, non-root image. GoodMem's core application data lives in PostgreSQL: original content, extracted text, chunks, dense and sparse vectors, page images, access-control records, and retrieval logs.

Can I point GoodMem at my own managed PostgreSQL?

Yes. The server takes a database URL and user as configuration, so you can run it against your existing managed PostgreSQL — RDS, Cloud SQL, or your own cluster — instead of the bundled container.

This is the recommended arrangement for production, because it puts backup, point-in-time recovery, failover, and monitoring under the tooling your team already operates. The database needs the pgvector extension available.

How should I size a deployment?

Sizing depends on your corpus size, embedding dimensions, ingest rate, and query volume. Because those variables interact, we do not publish a fixed sizing table; tell us your corpus size and expected query rate and we will help with provisioning.

For a proof of concept, one instance against a modest database is usually enough to load a representative sample and measure retrieval on your own data.

How do I back up and restore GoodMem?

Backing up the PostgreSQL database captures GoodMem's core application data, and standard PostgreSQL tooling — logical dumps, physical backups, point-in-time recovery on a managed service — is the supported path.

A complete recovery plan must also preserve deployment configuration, license material, TLS assets, credentials, and the required container images. The recovery objectives you can achieve therefore depend on both the database platform and your own tested restoration procedure. A review of your backup and recovery design is available as part of enterprise onboarding.

How do I monitor GoodMem in production?

GoodMem supports production monitoring with OpenTelemetry traces, Prometheus metrics, gRPC health checking, and separate liveness, readiness, and startup probes.

Traces cover API requests, retrieval work, calls to model providers, and background job attempts, and application logs include request IDs plus trace and span IDs when a span is active. OpenTelemetry export is off by default. Turning it on sends traces only, while metrics stay on the Prometheus endpoint and logs keep going where they go now.

Does GoodMem work with Langfuse, LangSmith, or our existing tracing backend?

GoodMem exports traces over OTLP and has verified configurations for Jaeger, Grafana Tempo, Langfuse, and LangSmith. Langfuse and LangSmith have dedicated export profiles for their metadata conventions.

Other destinations may work through an OpenTelemetry collector, though we have not verified them. For LangSmith, whether GoodMem spans show up under your own traces depends on sending them to the same LangSmith project and on the parent policy you configure.

Do GoodMem traces include our documents or prompts?

No. GoodMem traces do not include document content, query text, prompts, generated text, or credentials. The integration has no option to capture content, so the input and output panels in your tracing backend stay empty.

Traces do include operational metadata and identifiers for principals, API keys, and resources where available. An API-key identifier is its UUID, not the secret. Application logs, optional retrieval records, and license usage reporting are separate from trace export.

Can GoodMem run in a network-restricted or air-gapped environment?

Yes, GoodMem can run in a network-restricted or air-gapped environment. The install guide documents deployment from a mirrored registry, and a fully offline path in which images are exported, transferred, and loaded on the target host. Register only self-hosted model endpoints and run the OCR add-on locally, so nothing reaches an external provider.

The server only sends license telemetry when its license file enables it; a server running without a license file sends none. For an environment with no outbound connectivity, licensing without telemetry can be arranged under an enterprise agreement. Talk to us before planning an air-gapped rollout.

Security, access control, and data governance

Who can read a memory, what gets logged, and where customer data lives.

How does GoodMem isolate tenants?

A GoodMem instance is one database serving one tenant. Separating customers from one another therefore means running separate instances with separate databases, rather than partitioning inside a shared one.

Within an instance, spaces and access controls partition content among agents, teams, and workloads. These are logical authorization boundaries, not boundaries between independent customers. Requirements for separate compute, networks, cloud accounts, encryption domains, or failure domains have to be addressed in the deployment architecture itself.

How does access control work?

GoodMem controls access with roles and grants, and it evaluates them on every API request for a protected resource. Each permission pairs an operation with a selector that says which resources it applies to. A permission is granted directly to a principal or bundled into a role.

Roles exist at instance scope and at space scope, so a principal can administer the instance, or hold viewer, contributor, content-manager, or admin rights on an individual space. Principals are either people or service identities, which lets a production workload hold its own durable identity, so you can rotate credentials without changing who has access to what.

How do API keys work, and how do I limit what one can do?

API keys authenticate protected API requests, and a key can carry a permission ceiling that is fixed when the key is issued and cannot be widened afterwards.

A scoped key is evaluated twice: the subject must hold the permission, and the key's ceiling must also allow it. That lets you issue a key to an agent, a CI job, or an integration that holds strictly less authority than the identity behind it. Keys support validity windows. GoodMem stores only a verifier, not the key itself, and revoking a key is permanent.

Does GoodMem support SSO, SAML, OIDC, or SCIM?

GoodMem, the self-hosted server, does not support SSO, SAML, OIDC, or SCIM provisioning today. It authenticates with API keys, and people are onboarded with a one-time enrollment credential they exchange for their first key.

In self-hosted GoodMem, an administrator offboards someone by permanently deleting their user account. Every API key that acts as that user stops working, identity and audit history are preserved, and service identities they created or own keep working independently.

In GoodMem Cloud, you sign in to the GoodMem Cloud console at cloud.goodmem.ai with Google or GitHub, or with an emailed sign-in link. The console doesn't support SAML, SCIM, or connecting your own identity provider today.

Can I see what an agent retrieved?

Yes. GoodMem can maintain a retrieval activity log showing which principal and key ran a query, which spaces were queried, and what was returned.

Logging is governed by administrator policies that select which callers and spaces are recorded, so it is something you configure deliberately, not something that is on everywhere by default. Logging is asynchronous and best-effort. It records retrieval activity rather than every API operation, and should not be relied on as a complete security audit log. Records are written to daily partitions, so operators control retention through partition management.

What protects against instructions hidden in retrieved content?

To protect against instructions hidden in retrieved content, GoodMem wraps that content in delimiters that are specific to the request and carry a random nonce. The wrapper also carries a machine-readable classification that marks the content as untrusted data rather than instructions. Together these help a downstream consumer tell stored content apart from its own instructions.

The wrapper is a defense-in-depth signal for a model that reads it probabilistically; no parser enforces it as a boundary. Anyone who can contribute to a space can influence what your agents read, so treat contribution rights on a space as the security-relevant permission they are, and keep a human in the loop for consequential actions.

Can I use GoodMem with PHI or other regulated data?

The standard GoodMem Cloud service is not offered under a HIPAA business associate agreement or as a PCI-compliant environment. Unless you have a separate signed agreement with us, its terms do not allow protected health information, payment card numbers, government ID numbers, financial account credentials, biometric identifiers, or other specially regulated data.

For regulated workloads, customers commonly self-host so they control the infrastructure, the database, where data resides, and which model endpoints are called. Self-hosted GoodMem does not require Customer Content to be transmitted to PAIR Systems. Self-hosting does not by itself make a deployment compliant: you remain responsible for configuring and operating it to meet your own legal and compliance requirements. Talk to us to confirm the scope of any support or services before using GoodMem with regulated data.

What security certifications does GoodMem hold?

PAIR Systems holds an ISO/IEC 27001 certification and has completed a SOC 2 Type II audit. The SOC 2 audit covers the Security trust services criteria across PAIR Systems, including GoodMem Cloud.

Request the SOC 2 Type II report, certificates, and policy documentation through the trust center. Additional security evidence can be shared under NDA as part of a security review.

Do you train models on customer data?

PAIR Systems doesn't train shared or general-purpose models on customer data. In self-hosted GoodMem, PAIR Systems does not train models on your data at all. Self-hosted GoodMem does not require Customer Content to be transmitted to PAIR Systems; content you send to model providers you select, or share with us during support, is governed separately.

In GoodMem Cloud, PAIR Systems also doesn't use Customer Content to improve models or services for other customers; that commitment is in the Cloud terms of service. If you turn on the Auto-Optimizer, GoodMem Cloud fine-tunes embedding and reranking models on your data. Those models are trained only for you and serve only your deployment, and your data is never used for other customers. Fine-tuning relies on sub-processors, which are listed in our trust center; review that list before turning the Auto-Optimizer on.

Where is GoodMem Cloud data stored, and can I choose an EU region?

GoodMem Cloud stores your instance's data in the region you choose when you provision it, and offers EU regions including the Netherlands and Frankfurt, Germany. The PostgreSQL database holding your instance's data stays in that region.

Two things can send data outside your region for model processing. First, model endpoints depend on what you select: an LLM, embedder, or reranker hosted in the US processes the data you send it there, which does not change where your GoodMem database resides. Second, if you turn on the Auto-Optimizer, the data used to fine-tune your models may be processed outside your region. Account, billing, and analytics processing is covered separately by the privacy policy and data processing addendum.

Can uploaded code run inside GoodMem?

Yes. GoodMem supports extensions: packaged post-processors that an instance administrator uploads and that run inside the retrieval pipeline to transform results before they are returned.

Because an extension executes inside the server and sees retrieved content, uploading one is an administrative capability and should be governed like deploying code. Restrict the permission to the identities that genuinely need it, review what you upload, and if your threat model does not allow it, do not grant it to anyone.

Licensing, pricing, and support

License terms, cost, and where to get support.

Is GoodMem open source?

No. GoodMem is not open source. The server is proprietary software distributed as a binary under the GoodMem Free Binary License, which grants continuing rights to use versions you validly obtain, subject to the license's terms, but does not grant rights in the source code.

The client SDKs are published under Apache-2.0 and are open source; the server is not. "Free" in the license name refers to price for the covered uses, not to software freedom.

What may I do under the free binary license?

The free binary license lets you run unmodified GoodMem in your internal business operations, and inside products and services you provide to third parties, at no cost — including commercial SaaS products built on top of it.

What it does not allow is offering GoodMem itself as a standalone hosted, managed, or white-labelled GoodMem service, or modifying, reverse-engineering, or redistributing the software outside your own application. Rights continue for as long as you comply with the license. If your business model is close to that line, or you want managed-service or reseller rights, those are available under a commercial agreement.

Can I ship GoodMem inside my own Docker image or installer?

Yes, you can ship GoodMem inside your own Docker image or installer, subject to the embedded-distribution conditions in the GoodMem Free Binary License. GoodMem must remain a component of the application you deliver rather than a standalone GoodMem service, and your end-user terms must protect PAIR Systems' rights as the license requires.

That covers shipping it in a container image, a virtual machine image, or an on-premises installer alongside your own software. What it does not cover is distributing GoodMem on its own, or running it as a hosted GoodMem service for others.

What happens to my deployment if PAIR Systems stops operating?

A self-hosted GoodMem deployment is designed to operate on infrastructure you control, without ongoing connectivity to PAIR Systems. Your content, embeddings, and access policies remain in your own PostgreSQL database.

Subject to continued compliance with the license, you may keep using versions you validly obtained. Continued operation depends on retaining the necessary software artifacts and on maintaining your infrastructure, configuration, credentials, and model endpoints. What would no longer be available from PAIR Systems is future releases and support. Enterprise agreements may also include source-code escrow and continuity rights, with release conditions defined in advance.

How is GoodMem Cloud priced?

GoodMem Cloud bills for three things: instance compute, by the second while the instance is running; the database storage provisioned for the instance; and, if you turn on the Auto-Optimizer, the compute that its fine-tuning runs use, metered against a spend cap you set. There is no per-memory, per-API-call, or per-seat charge.

Pausing an instance stops compute charges while storage keeps billing. Current rates are in the console, and there is a free 14-day trial with no credit card.

How much storage will my corpus actually use?

Expect a stored footprint substantially larger than your source documents, because GoodMem keeps the original content, the extracted text, the chunks, dense and sparse vectors, and optionally rendered page images.

In one measured workload a document expanded by roughly thirty times, with page images accounting for most of that. Actual ratios vary materially with document format, page-image settings, chunking, and embedding dimensions, so measure a representative sample when sizing a deployment. Our total-cost analysis walks through the measurement and the arithmetic.

What does self-hosting cost?

Self-hosting GoodMem costs nothing in license fees for the uses the free binary license covers, including commercial use. Your costs are the infrastructure you run it on and the inference providers you register.

There are no artificial caps on the number of memories or spaces on a node; capacity is whatever your hardware and database sustain. Enterprise agreements add commercial terms such as support tiers, service levels, and the continuity arrangements described above.

Is there a service level agreement?

A 99.99% uptime service level agreement is available as part of a signed enterprise agreement. The standard Cloud terms of service do not carry an availability commitment, and self-hosted deployments run on your own infrastructure, so their availability is yours to manage.

If you need a contractual uptime commitment with defined measurement and remedies, that is an enterprise conversation rather than something the self-serve tiers include.

What support do I get, and who do I contact when something breaks?

Free self-hosted and self-serve Cloud users get help through the community forum on a best-effort basis with no response target. GoodMem deployed from Google Cloud Marketplace includes Basic Email Support (support@pairsys.ai, weekdays 9 a.m. to 5 p.m. Pacific, response within two business days). Enterprise licenses add contractual support tiers, with initial response targets as short as one business day and, at the most stringent level, 24/7 coverage and a two-hour initial response target for severity-one incidents.

Security vulnerabilities should always be reported privately through the disclosure process, whatever tier you're on.

About this FAQ

This page summarizes current product capabilities and general commercial offerings. It does not modify the GoodMem license, the Cloud Terms of Service, the Data Processing Addendum, or any signed agreement. Contractual service levels, support commitments, and negotiated rights are governed by the applicable agreement. References to planned features reflect current direction and are not delivery commitments.

Not answered here?

The documentation goes deeper on every topic here. For security reviews, deployment architecture, sizing, or anything commercial, talk to us.