REST API for server-side agent memory.

// quickstart.ts
// Run with: PUMADB_API_KEY=puma_live_... npx tsx quickstart.ts
const apiKey = process.env.PUMADB_API_KEY;

if (!apiKey) {
  throw new Error("Set PUMADB_API_KEY before running this script.");
}

type PumaRow = {
  id: string;
  title: string;
  status: string;
  created_at: string;
  updated_at: string;
};

async function puma<T>(path: string, init: { method?: string; body?: string } = {}): Promise<T> {
  const response = await fetch("https://api.pumadb.ai" + path, {
    method: init.method,
    body: init.body,
    headers: {
      Authorization: "Bearer " + apiKey,
      "Content-Type": "application/json"
    }
  });

  if (!response.ok) {
    throw new Error(await response.text());
  }

  return response.json() as Promise<T>;
}

const created = await puma<PumaRow>("/v1/tasks", {
  method: "POST",
  body: JSON.stringify({ title: "ship docs", status: "open" })
});

const result = await puma<{ rows: PumaRow[] }>("/v1/tasks?limit=25");
const found = result.rows.find((row) => row.id === created.id);

if (!found) {
  throw new Error("Created row was not returned by GET /v1/tasks.");
}

console.log("created=" + created.id + " fetched=" + found.title + " status=" + found.status);

// Expected output:
// created=row_... fetched=ship docs status=open

# quickstart.py
# Run with: PUMADB_API_KEY=puma_live_... python3 quickstart.py
import json
import os
import urllib.error
import urllib.request

BASE_URL = "https://api.pumadb.ai"
API_KEY = os.environ.get("PUMADB_API_KEY")

if not API_KEY:
    raise SystemExit("Set PUMADB_API_KEY before running this script.")


def puma(path, method="GET", body=None):
    data = None if body is None else json.dumps(body).encode("utf-8")
    request = urllib.request.Request(
        BASE_URL + path,
        data=data,
        method=method,
        headers={
            "Authorization": "Bearer " + API_KEY,
            "Content-Type": "application/json",
        },
    )
    try:
        with urllib.request.urlopen(request) as response:
            return json.loads(response.read().decode("utf-8"))
    except urllib.error.HTTPError as error:
        raise RuntimeError(error.read().decode("utf-8")) from error


created = puma("/v1/tasks", "POST", {"title": "ship docs", "status": "open"})
result = puma("/v1/tasks?limit=25")
found = next((row for row in result["rows"] if row["id"] == created["id"]), None)

if not found:
    raise RuntimeError("Created row was not returned by GET /v1/tasks.")

print({"created": created["id"], "fetched": found["title"], "status": found["status"]})

// quickstart.go
// Run with: PUMADB_API_KEY=puma_live_... go run quickstart.go
package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
)

const baseURL = "https://api.pumadb.ai"

type Row struct {
  ID        string `json:"id"`
  Title     string `json:"title"`
  Status    string `json:"status"`
  CreatedAt string `json:"created_at"`
  UpdatedAt string `json:"updated_at"`
}

type QueryResponse struct {
  Rows []Row `json:"rows"`
}

func puma(method, path string, body any, out any) error {
  var reader io.Reader
  if body != nil {
    encoded, err := json.Marshal(body)
    if err != nil {
      return err
    }
    reader = bytes.NewReader(encoded)
  }

  req, err := http.NewRequest(method, baseURL+path, reader)
  if err != nil {
    return err
  }
  req.Header.Set("Authorization", "Bearer "+os.Getenv("PUMADB_API_KEY"))
  req.Header.Set("Content-Type", "application/json")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    return err
  }
  defer res.Body.Close()

  data, err := io.ReadAll(res.Body)
  if err != nil {
    return err
  }
  if res.StatusCode < 200 || res.StatusCode >= 300 {
    return fmt.Errorf("%s", data)
  }
  return json.Unmarshal(data, out)
}

func main() {
  if os.Getenv("PUMADB_API_KEY") == "" {
    panic("Set PUMADB_API_KEY before running this program.")
  }

  var created Row
  err := puma("POST", "/v1/tasks", map[string]string{
    "title": "ship docs",
    "status": "open",
  }, &created)
  if err != nil {
    panic(err)
  }

  var result QueryResponse
  if err := puma("GET", "/v1/tasks?limit=25", nil, &result); err != nil {
    panic(err)
  }

  for _, row := range result.Rows {
    if row.ID == created.ID {
      fmt.Printf("created=%s fetched=%s status=%s\n", created.ID, row.Title, row.Status)
      return
    }
  }

  panic("Created row was not returned by GET /v1/tasks.")
}