# Everything under the hood

Source: <https://goodmem.ai/features>

Title: Features | Goodmem

> Explore Goodmem features like vector storage, agent hooks, analytics, and enterprise security to run production-grade AI memory workflows with confidence.

Memory primitives, semantic search, pluggable embeddings, and the dev tools to wire it all together.

## Memory Primitives

Store, embed, and retrieve memories with semantic understanding and vector search capabilities.

## Intelligent Search

Find relevant memories using natural language queries and context-aware semantic matching.

## Agent Hooks

Seamlessly integrate memory operations into your agent workflows with simple API calls.

## Built for production

Enterprise-grade features that scale with your AI applications, from prototype to production.

### Vector Store

High-performance vector database optimized for AI workloads with automatic embedding generation.

- Support for multiple embedding models
- Automatic chunking and preprocessing
- Hybrid search (sparse and dense vectors)
- Real-time indexing and updates

### Lightning Performance

Low-latency vector search with intelligent caching and optimized data structures.

- Filtering over arbitrary JSON metadata
- Retrieval time varies with collection size, result count, and reranking
- PostgreSQL-backed query optimization
- Batch processing capabilities
- PostgreSQL-based auto-scaling infrastructure

### Enterprise Security

Built-in access control and data governance for production environments.

- TLS for REST and gRPC, with automated certificate renewal
- Instance and space roles, resource grants, and scoped API keys
- Human and service identities with managed enrollment and ownership
- PAIR Systems is ISO 27001 certified; its SOC 2 Type II audit is in progress

### Multi-Agent Support

Manage memories across multiple agents with shared and isolated contexts.

- Isolated and shared memory contexts
- Agent-specific namespaces and permissions

### Developer Tools

Comprehensive SDKs, debugging tools, and development workflows for any stack.

- Multi-language SDKs
- Command-line interface (CLI)
- HTTP REST and gRPC API support

### Document Ingestion & Visual RAG

Turn documents into searchable, visually-grounded memory — PDF, Word, PowerPoint, and Excel.

- No LibreOffice — pure-JVM page rendering
- Faithful tables, charts, and layout
- Page-level grounding for precise citations
- Multimodal-ready for vision-model retrieval

Built by ISO 27001-certified PAIR Systems. Our SOC 2 Type II audit is in progress. [Visit our Trust Center](https://trust.pairsys.ai/)

## Your documents, rendered

GoodMem turns PDFs and Office files into per-page images, so your agents retrieve over what a document actually looks like — tables, charts, and layout — not a flattened text dump.

PDF DOCX PPTX XLSX

### No LibreOffice required

Pure-JVM, server-side rendering with no headless Office subprocess to operate or secure — deterministic output that is container- and air-gap-friendly.

### Faithful to the page

Tables, charts, conditional formatting, embedded images and effects, and right-to-left scripts like Arabic are rendered, not stripped.

### Grounded citations

Every chunk maps back to its source page, so retrieval results can cite exactly where an answer came from.

## Built-in web console

Manage resources, upload documents, and search your knowledge base — all from your browser. Launches automatically with the server.

![GoodMem web console showing system health, resource status, and getting started checklist](https://goodmem.ai/images/console-overview.png)

[Console Documentation](https://docs.goodmem.ai/docs/reference/console)

## Simple, powerful API

Get started with just a few lines of code. Our intuitive API makes memory management effortless across all supported languages.

Python TypeScript Go Java .NET Shell

```
import requests, json
BASE_URL = "http://localhost:8080"HEADERS = {"x-api-key": "your-api-key", "Content-Type": "application/json"}
# Store a memorymemory = requests.post(f"{BASE_URL}/v1/memories", headers=HEADERS, json={    "spaceId": "your-space-id",    "contentType": "text/plain",    "originalContent": "User prefers dark mode and Python"}).json()print(f"Stored: {memory['memoryId']}")
# Search with natural languageresults = requests.post(    f"{BASE_URL}/v1/memories:retrieve",    headers={**HEADERS, "Accept": "application/x-ndjson"},    json={        "message": "What are the user's preferences?",        "spaceKeys": [{"spaceId": "your-space-id"}]    })for line in results.text.strip().split("\n"):    if line:        print(json.loads(line))
```

```
// npm install @pairsystems/goodmemimport * as GoodMemClient from '@pairsystems/goodmem';const { StreamingClient } = GoodMemClient;
// Configure clientconst client = GoodMemClient.ApiClient.instance;client.basePath = 'http://localhost:8080';client.defaultHeaders = { 'X-API-Key': 'your-api-key' };
const memoriesApi = new GoodMemClient.MemoriesApi();const streamingClient = new StreamingClient(client);
// Store a memoryconst memory = await memoriesApi.createMemory({  spaceId: 'your-space-id',  contentType: 'text/plain',  originalContent: 'User prefers dark mode and React'});console.log('Stored:', memory.memoryId);
// Search with streamingconst stream = await streamingClient.retrieveMemoryStreamAdvanced(  new AbortController().signal,  {    message: "What are the user's preferences?",    spaceIds: ['your-space-id'],    format: 'ndjson'  });for await (const event of stream) {  console.log(JSON.stringify(event, null, 2));}
```

```
// GOPROXY="https://go-proxy.fury.io/pairsys/"// GOPRIVATE="github.com/PAIR-Systems-Inc/goodmem"// GONOPROXY=none// go get github.com/PAIR-Systems-Inc/goodmem/clients/go
package main
import (    "context"    "encoding/json"    "fmt"
    goodmem "github.com/PAIR-Systems-Inc/goodmem/clients/go")
func main() {    cfg := goodmem.NewConfiguration()    cfg.Servers = goodmem.ServerConfigurations{{URL: "http://localhost:8080"}}    cfg.AddDefaultHeader("x-api-key", "your-api-key")    client := goodmem.NewAPIClient(cfg)    ctx := context.Background()
    // Store a memory    memReq := goodmem.NewMemoryCreationRequest("your-space-id", "text/plain")    memReq.SetOriginalContent("User prefers dark mode and Go")
    memory, _, _ := client.MemoriesAPI.CreateMemory(ctx).        MemoryCreationRequest(*memReq).Execute()    fmt.Printf("Stored: %s\n", memory.GetMemoryId())
    // Search with streaming    streamClient := goodmem.NewStreamingClient(client)    stream, _ := streamClient.RetrieveMemoryStreamAdvanced(ctx,        &goodmem.AdvancedMemoryStreamRequest{            Message:  "What are the user's preferences?",            SpaceIDs: []string{"your-space-id"},            Format:   goodmem.FormatNDJSON,        })    for event := range stream {        out, _ := json.MarshalIndent(event, "", "  ")        fmt.Println(string(out))    }}
```

```
// build.gradle: implementation 'ai.pairsys.goodmem:goodmem-client-java'import ai.goodmem.client.*;import ai.goodmem.client.api.*;import ai.goodmem.client.model.*;
ApiClient client = Configuration.getDefaultApiClient();client.setBasePath("http://localhost:8080");client.addDefaultHeader("x-api-key", "your-api-key");
MemoriesApi memoriesApi = new MemoriesApi(client);
// Store a memoryMemoryCreationRequest req = new MemoryCreationRequest();req.setSpaceId("your-space-id");req.setContentType("text/plain");req.setOriginalContent("User prefers dark mode and Java");
MemoryResponse memory = memoriesApi.createMemory(req);System.out.println("Stored: " + memory.getMemoryId());
// Search with streamingStreamingClient streamClient = new StreamingClient(client);AdvancedMemoryStreamRequest search = new AdvancedMemoryStreamRequest();search.setMessage("What are the user's preferences?");search.setSpaceIds(List.of("your-space-id"));search.setFormat("ndjson");
streamClient.retrieveMemoryStreamAdvanced(search)    .forEach(event -> System.out.println(event));
```

```
// dotnet add package Pairsystems.Goodmem.Clientusing Pairsystems.Goodmem.Client;using Pairsystems.Goodmem.Client.Api;using Pairsystems.Goodmem.Client.Model;
var config = new Configuration { BasePath = "http://localhost:8080" };config.DefaultHeaders.Add("x-api-key", "your-api-key");
var memoriesApi = new MemoriesApi(config);
// Store a memoryvar req = new MemoryCreationRequest(    spaceId: "your-space-id",    contentType: "text/plain",    originalContent: "User prefers dark mode and C#");
var memory = await memoriesApi.CreateMemoryAsync(req);Console.WriteLine(quot;Stored: {memory.MemoryId}");
// Search with streamingvar streamingClient = new StreamingClient(config);var search = new AdvancedMemoryStreamRequest{    Message = "What are the user's preferences?",    SpaceIds = new List<string> { "your-space-id" },    Format = "ndjson"};
await foreach (var evt in streamingClient.RetrieveMemoryStreamAdvancedAsync(search)){    Console.WriteLine(JsonSerializer.Serialize(evt));}
```

```
# Store a memorycurl -s http://localhost:8080/v1/memories \  -H "x-api-key: your-api-key" \  -H "Content-Type: application/json" \  -d '{    "spaceId": "your-space-id",    "contentType": "text/plain",    "originalContent": "User prefers dark mode"  }'
# Search with natural languagecurl -s http://localhost:8080/v1/memories:retrieve \  -H "x-api-key: your-api-key" \  -H "Content-Type: application/json" \  -H "Accept: application/x-ndjson" \  -d '{    "message": "What are the user preferences?",    "spaceKeys": [{"spaceId": "your-space-id"}]  }'
```

## Works with your stack

Native SDKs and integrations for popular AI frameworks, providers, and programming languages.

[View all integrations](https://goodmem.ai/integrations)

## Ready to give your agents memory?

Start building with GoodMem today. No setup required, just add intelligence to your agents in minutes.

[Start Building](https://goodmem.ai/quick-start) [View Pricing](https://goodmem.ai/pricing)