@agentmemory/agentmemory 0.7.0

package/src/state/vector-index.ts

@@ -0,0 +1,130 @@
+function float32ToBase64(arr: Float32Array): string {
+  return Buffer.from(arr.buffer).toString("base64");
+}
+
+function base64ToFloat32(b64: string): Float32Array {
+  return new Float32Array(Buffer.from(b64, "base64").buffer);
+}
+
+function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+export class VectorIndex {
+  private vectors: Map<string, { embedding: Float32Array; sessionId: string }> =
+    new Map();
+
+  add(obsId: string, sessionId: string, embedding: Float32Array): void {
+    this.vectors.set(obsId, { embedding, sessionId });
+  }
+
+  remove(obsId: string): void {
+    this.vectors.delete(obsId);
+  }
+
+  search(
+    query: Float32Array,
+    limit = 20,
+  ): Array<{ obsId: string; sessionId: string; score: number }> {
+    const results: Array<{
+      obsId: string;
+      sessionId: string;
+      score: number;
+    }> = [];
+    let minScore = -Infinity;
+
+    for (const [obsId, entry] of this.vectors) {
+      const score = cosineSimilarity(query, entry.embedding);
+      if (results.length < limit) {
+        results.push({ obsId, sessionId: entry.sessionId, score });
+        if (results.length === limit) {
+          results.sort((a, b) => a.score - b.score);
+          minScore = results[0].score;
+        }
+      } else if (score > minScore) {
+        results[0] = { obsId, sessionId: entry.sessionId, score };
+        results.sort((a, b) => a.score - b.score);
+        minScore = results[0].score;
+      }
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return results;
+  }
+
+  get size(): number {
+    return this.vectors.size;
+  }
+
+  clear(): void {
+    this.vectors.clear();
+  }
+
+  restoreFrom(other: VectorIndex): void {
+    const src = (other as any).vectors as Map<
+      string,
+      { embedding: Float32Array; sessionId: string }
+    >;
+    this.vectors = new Map();
+    for (const [obsId, entry] of src) {
+      this.vectors.set(obsId, {
+        embedding: new Float32Array(entry.embedding),
+        sessionId: entry.sessionId,
+      });
+    }
+  }
+
+  serialize(): string {
+    const data: Array<[string, { embedding: string; sessionId: string }]> = [];
+    for (const [obsId, entry] of this.vectors) {
+      data.push([
+        obsId,
+        {
+          embedding: float32ToBase64(entry.embedding),
+          sessionId: entry.sessionId,
+        },
+      ]);
+    }
+    return JSON.stringify(data);
+  }
+
+  static deserialize(json: string): VectorIndex {
+    const idx = new VectorIndex();
+    let data: unknown;
+    try {
+      data = JSON.parse(json);
+    } catch {
+      return idx;
+    }
+    if (!Array.isArray(data)) return idx;
+    for (const row of data) {
+      try {
+        if (!Array.isArray(row) || row.length < 2) continue;
+        const [obsId, entry] = row;
+        if (
+          typeof obsId !== "string" ||
+          typeof entry?.embedding !== "string" ||
+          typeof entry?.sessionId !== "string"
+        )
+          continue;
+        idx.vectors.set(obsId, {
+          embedding: base64ToFloat32(entry.embedding),
+          sessionId: entry.sessionId,
+        });
+      } catch {
+        continue;
+      }
+    }
+    return idx;
+  }
+}

package/src/telemetry/setup.ts

@@ -0,0 +1,116 @@
+import { VERSION } from "../version.js";
+
+interface OtelConfig {
+  serviceName: string;
+  serviceVersion: string;
+  metricsExportIntervalMs: number;
+}
+
+export const OTEL_CONFIG: OtelConfig = {
+  serviceName: "agentmemory",
+  serviceVersion: VERSION,
+  metricsExportIntervalMs: 30_000,
+};
+
+interface Counter {
+  add: (n: number) => void;
+}
+interface Histogram {
+  record: (v: number) => void;
+}
+
+interface Counters {
+  observationsTotal: Counter;
+  compressionSuccess: Counter;
+  compressionFailure: Counter;
+  searchTotal: Counter;
+  dedupSkipped: Counter;
+  evictionTotal: Counter;
+  circuitBreakerOpen: Counter;
+  embeddingSuccess: Counter;
+  embeddingFailure: Counter;
+  vectorSearchTotal: Counter;
+  autoForgetTotal: Counter;
+  profileGenerated: Counter;
+  claudeBridgeSync: Counter;
+  graphExtraction: Counter;
+  consolidationRun: Counter;
+  teamShare: Counter;
+  auditLog: Counter;
+  snapshotCreate: Counter;
+  governanceDelete: Counter;
+}
+
+interface Histograms {
+  compressionLatency: Histogram;
+  searchLatency: Histogram;
+  contextTokens: Histogram;
+  qualityScore: Histogram;
+  embeddingLatency: Histogram;
+  vectorSearchLatency: Histogram;
+}
+
+type Meter = {
+  createCounter: (name: string) => Counter;
+  createHistogram: (name: string) => Histogram;
+};
+
+let counters: Counters | null = null;
+let histograms: Histograms | null = null;
+
+const NOOP_COUNTER: Counter = { add: () => {} };
+const NOOP_HISTOGRAM: Histogram = { record: () => {} };
+
+const COUNTER_NAMES: Array<[keyof Counters, string]> = [
+  ["observationsTotal", "observations.total"],
+  ["compressionSuccess", "compression.success"],
+  ["compressionFailure", "compression.failure"],
+  ["searchTotal", "search.total"],
+  ["dedupSkipped", "dedup.skipped"],
+  ["evictionTotal", "eviction.total"],
+  ["circuitBreakerOpen", "circuit_breaker.open"],
+  ["embeddingSuccess", "embedding.success"],
+  ["embeddingFailure", "embedding.failure"],
+  ["vectorSearchTotal", "vector_search.total"],
+  ["autoForgetTotal", "auto_forget.total"],
+  ["profileGenerated", "profile.generated"],
+  ["claudeBridgeSync", "claude_bridge.sync"],
+  ["graphExtraction", "graph.extraction"],
+  ["consolidationRun", "consolidation.run"],
+  ["teamShare", "team.share"],
+  ["auditLog", "audit.log"],
+  ["snapshotCreate", "snapshot.create"],
+  ["governanceDelete", "governance.delete"],
+];
+
+const HISTOGRAM_NAMES: Array<[keyof Histograms, string]> = [
+  ["compressionLatency", "compression.latency_ms"],
+  ["searchLatency", "search.latency_ms"],
+  ["contextTokens", "context.tokens"],
+  ["qualityScore", "quality.score"],
+  ["embeddingLatency", "embedding.latency_ms"],
+  ["vectorSearchLatency", "vector_search.latency_ms"],
+];
+
+export function initMetrics(getMeter?: (name: string) => Meter): {
+  counters: Counters;
+  histograms: Histograms;
+} {
+  const meter = getMeter?.("agentmemory");
+
+  counters = Object.fromEntries(
+    COUNTER_NAMES.map(([key, name]) => [
+      key,
+      meter ? meter.createCounter(name) : NOOP_COUNTER,
+    ]),
+  ) as unknown as Counters;
+
+  histograms = Object.fromEntries(
+    HISTOGRAM_NAMES.map(([key, name]) => [
+      key,
+      meter ? meter.createHistogram(name) : NOOP_HISTOGRAM,
+    ]),
+  ) as unknown as Histograms;
+
+  return { counters, histograms };
+}