An agent that uses memory

afy deploy

name: support-bot
runtime: python3.11
type: service
memory_mb: 256

name: memory-demo-py
runtime: python3.11
type: job
memory_mb: 256

aetherfy-vectors

"""An Aetherfy agent that writes a memory and searches it back.
 
Runs as a `job`: it executes once and exits. No API key is configured
anywhere — MemoryClient() reads AETHERFY_API_KEY, which the Aetherfy
agent machine provides automatically.
"""
 
import hashlib
import os
from typing import List
 
from aetherfy_memory import MemoryClient
from aetherfy_memory.exceptions import NamespaceAlreadyExistsError
 
 
def embed(text: str) -> List[float]:
    """REPLACE ME with a real embedding model.
 
    Aetherfy does not generate embeddings — every memory write must carry
    a vector you computed. This placeholder is deterministic (so the agent
    runs as written) but not semantic. See /examples/embeddings.
    """
    h = hashlib.sha256(text.encode()).digest()
    return [h[i % len(h)] / 255.0 for i in range(384)]
 
 
def main() -> None:
    print("agent", os.environ.get("AETHERFY_AGENT_NAME"),
          "region", os.environ.get("AETHERFY_REGION"))
 
    # No arguments: the API key comes from AETHERFY_API_KEY.
    memory = MemoryClient()
 
    namespace_name = "customer-42"
    try:
        memory.create_namespace(namespace_name)
        print("created namespace", namespace_name)
    except NamespaceAlreadyExistsError:
        print("namespace already exists", namespace_name)
 
    ns = memory.namespace(namespace_name)
 
    # Write a memory. add() is keyword-only and returns the point id.
    memory_id = ns.add(
        text="Lives in NYC and prefers email",
        vector=embed("Lives in NYC and prefers email"),
        metadata={"source": "support-transcript"},
    )
    print("wrote memory", memory_id)
 
    # Read it back. search() is keyword-only in Python.
    results = ns.search(
        vector=embed("where is the customer based?"),
        limit=3,
        with_payload=True,
    )
    for r in results:
        print("hit", r.id, r.payload)
    # hit <uuid> {'text': 'Lives in NYC and prefers email',
    #             'metadata': {'source': 'support-transcript'}}
 
    print("total memories", ns.count())
 
 
if __name__ == "__main__":
    main()

afy deploy

name: memory-demo-node
runtime: node22
type: job
memory_mb: 256

{
  "name": "memory-demo-node",
  "private": true,
  "type": "module",
  "main": "index.js",
  "dependencies": {
    "aetherfy-vectors": "*"
  }
}

/**
 * An Aetherfy agent that writes a memory and searches it back.
 *
 * Runs as a `job`: it executes once and exits. No API key is configured
 * anywhere — new MemoryClient() reads AETHERFY_API_KEY, which the Aetherfy
 * agent machine provides automatically.
 */
 
import { createHash } from 'node:crypto';
import { MemoryClient, NamespaceAlreadyExistsError } from 'aetherfy-vectors';
 
/**
 * REPLACE ME with a real embedding model.
 *
 * Aetherfy does not generate embeddings — every memory write must carry a
 * vector you computed. This placeholder is deterministic (so the agent runs
 * as written) but not semantic. See /examples/embeddings.
 */
function embed(text) {
  const h = createHash('sha256').update(text).digest();
  return Array.from({ length: 384 }, (_, i) => h[i % h.length] / 255);
}
 
async function main() {
  console.log('agent', process.env.AETHERFY_AGENT_NAME,
              'region', process.env.AETHERFY_REGION);
 
  // No arguments: the API key comes from AETHERFY_API_KEY.
  const memory = new MemoryClient();
 
  const namespaceName = 'customer-42';
  try {
    await memory.createNamespace(namespaceName);
    console.log('created namespace', namespaceName);
  } catch (e) {
    if (!(e instanceof NamespaceAlreadyExistsError)) throw e;
    console.log('namespace already exists', namespaceName);
  }
 
  const ns = await memory.namespace(namespaceName);
 
  // Write a memory. add() takes one options object and resolves to the id.
  const memoryId = await ns.add({
    text: 'Lives in NYC and prefers email',
    vector: embed('Lives in NYC and prefers email'),
    metadata: { source: 'support-transcript' },
  });
  console.log('wrote memory', memoryId);
 
  // Read it back. search() takes the vector positionally in JavaScript.
  const results = await ns.search(embed('where is the customer based?'), {
    limit: 3,
    withPayload: true,
  });
  for (const r of results) console.log('hit', r.id, r.payload);
  // hit <uuid> { text: 'Lives in NYC and prefers email',
  //              metadata: { source: 'support-transcript' } }
 
  console.log('total memories', await ns.count());
}
 
main();

afy deploy

from aetherfy_memory import MemoryClient
from aetherfy_memory.exceptions import ThreadAlreadyExistsError
 
memory = MemoryClient()
 
try:
    memory.create_thread("conv-99")
except ThreadAlreadyExistsError:
    pass
 
chat = memory.thread("conv-99")
chat.add(role="user", content="Can you reset my password?",
         vector=embed("Can you reset my password?"))
chat.add(role="assistant", content="I've sent a reset link.",
         vector=embed("I've sent a reset link."))
 
# Rebuild the recent context to hand to your model.
context = [(m.role, m.content) for m in chat.history(limit=20)]
print(context)
# [('user', 'Can you reset my password?'), ('assistant', "I've sent a reset link.")]

import { MemoryClient, ThreadAlreadyExistsError } from 'aetherfy-vectors';
 
const memory = new MemoryClient();
 
try {
  await memory.createThread('conv-99');
} catch (e) {
  if (!(e instanceof ThreadAlreadyExistsError)) throw e;
}
 
const chat = await memory.thread('conv-99');
await chat.add({ role: 'user', content: 'Can you reset my password?',
                 vector: embed('Can you reset my password?') });
await chat.add({ role: 'assistant', content: "I've sent a reset link.",
                 vector: embed("I've sent a reset link.") });
 
const context = (await chat.history({ limit: 20 })).map((m) => [m.role, m.content]);
console.log(context);
// [ [ 'user', 'Can you reset my password?' ],
//   [ 'assistant', "I've sent a reset link." ] ]