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));
}

// 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 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"}]
  }'