Everything under the hood

// npm install @pairsystems/goodmem
import * as GoodMemClient from '@pairsystems/goodmem';
const { StreamingClient } = GoodMemClient;

// Configure client
const 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 memory
const 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 streaming
const 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));
}

// go get github.com/PAIR-Systems-Inc/goodmem-go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    goodmem "github.com/PAIR-Systems-Inc/goodmem-go"
    "github.com/PAIR-Systems-Inc/goodmem-go/models"
)

func main() {
    client, err := goodmem.New("http://localhost:8080", "your-api-key")
    if err != nil {
        log.Fatal(err)
    }
    ctx := context.Background()

    // Store a memory
    memory, err := client.Memories().Create(ctx, &models.JSONMemoryCreationRequest{
        SpaceID: "your-space-id",
        OriginalContent: goodmem.Ptr("User prefers dark mode and Go"),
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Stored: %s\n", memory.MemoryID)

    // Search with streaming
    stream, err := client.Memories().Retrieve(ctx, "What are the user's preferences?",
        &goodmem.RetrieveOptions{
            SpaceIDs: []string{"your-space-id"},
        })
    if err != nil {
        log.Fatal(err)
    }
    defer stream.Close()
    for event, err := range stream.Events() {
        if err != nil {
            log.Fatal(err)
        }
        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 memory
MemoryCreationRequest 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 streaming
StreamingClient 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.Client
using 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 memory
var 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 streaming
var 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 memory
curl -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 language
curl -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"}]
  }'