@199-bio/engram 0.11.1 → 0.13.0

package/src/retrieval/jina-bridge.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Jina v5 embedding bridge for Engram
+Uses jina-embeddings-v5-small with MLX Metal acceleration (~9ms/query, 1.6GB RAM)
+
+Drop-in replacement for colbert-bridge.py.
+Run as subprocess from Node.js, communicates via JSON over stdin/stdout.
+
+Vector store: numpy arrays in-memory, persisted to .npz + .json sidecar files.
+Search: cosine similarity via normalized dot product (vectors normalized at embed time).
+"""
+
+import sys
+import json
+import os
+from pathlib import Path
+
+import numpy as np
+
+EMBEDDING_DIM = 256  # Matryoshka truncation dimension
+MODEL_NAME = "jina-embeddings-v5-small"
+
+
+def lazy_load_embedder():
+    """Lazy load jina_grep LocalEmbedder to speed up startup."""
+    try:
+        from jina_grep.embedder import LocalEmbedder
+        return LocalEmbedder
+    except ImportError:
+        return None
+
+
+class JinaBridge:
+    def __init__(self, index_path: str):
+        self.index_path = Path(index_path)
+        self.index_path.mkdir(parents=True, exist_ok=True)
+
+        self.vectors_file = self.index_path / "engram_vectors.npz"
+        self.meta_file = self.index_path / "engram_meta.json"
+
+        self.embedder = None
+        self.vectors: np.ndarray | None = None  # shape (n, EMBEDDING_DIM), L2-normalized
+        self.doc_ids: list[str] = []
+        self.doc_contents: dict[str, str] = {}  # id -> content
+
+        self._load_from_disk()
+
+    # ------------------------------------------------------------------
+    # Embedder lifecycle
+    # ------------------------------------------------------------------
+
+    def _ensure_embedder(self):
+        """Load embedder model on first use."""
+        if self.embedder is None:
+            LocalEmbedder = lazy_load_embedder()
+            if LocalEmbedder is None:
+                raise RuntimeError(
+                    "jina_grep not installed. Run: pip install jina-grep"
+                )
+            self.embedder = LocalEmbedder()
+
+    # ------------------------------------------------------------------
+    # Persistence
+    # ------------------------------------------------------------------
+
+    def _load_from_disk(self):
+        """Load existing vectors and metadata from disk if present."""
+        if self.vectors_file.exists() and self.meta_file.exists():
+            try:
+                data = np.load(self.vectors_file)
+                self.vectors = data["vectors"]
+
+                with open(self.meta_file, "r") as f:
+                    meta = json.load(f)
+                self.doc_ids = meta.get("doc_ids", [])
+                self.doc_contents = meta.get("doc_contents", {})
+            except Exception:
+                # Corrupted files -- start fresh
+                self.vectors = None
+                self.doc_ids = []
+                self.doc_contents = {}
+
+    def _persist(self):
+        """Write current vectors and metadata to disk."""
+        if self.vectors is not None and len(self.doc_ids) > 0:
+            np.savez(self.vectors_file, vectors=self.vectors)
+            with open(self.meta_file, "w") as f:
+                json.dump(
+                    {"doc_ids": self.doc_ids, "doc_contents": self.doc_contents},
+                    f,
+                )
+        else:
+            # Empty index -- remove stale files
+            if self.vectors_file.exists():
+                self.vectors_file.unlink()
+            if self.meta_file.exists():
+                self.meta_file.unlink()
+
+    # ------------------------------------------------------------------
+    # Embedding helpers
+    # ------------------------------------------------------------------
+
+    def _embed(self, texts: list[str]) -> np.ndarray:
+        """Embed a list of texts and return L2-normalized vectors (n, EMBEDDING_DIM)."""
+        self._ensure_embedder()
+        raw = self.embedder.embed(texts, model=MODEL_NAME, task="retrieval")
+        vecs = np.array(raw, dtype=np.float32)
+
+        # Matryoshka truncation to target dimension
+        if vecs.shape[1] > EMBEDDING_DIM:
+            vecs = vecs[:, :EMBEDDING_DIM]
+
+        # L2-normalize so dot product == cosine similarity
+        norms = np.linalg.norm(vecs, axis=1, keepdims=True)
+        norms = np.where(norms == 0, 1, norms)
+        vecs = vecs / norms
+
+        return vecs
+
+    # ------------------------------------------------------------------
+    # Actions
+    # ------------------------------------------------------------------
+
+    def index_documents(self, documents: list[dict]) -> dict:
+        """
+        Build a fresh index from documents.
+        documents: [{"id": "...", "content": "..."}]
+        """
+        if not documents:
+            return {"success": True, "count": 0}
+
+        ids = [d["id"] for d in documents]
+        contents = [d["content"] for d in documents]
+
+        vecs = self._embed(contents)
+
+        self.vectors = vecs
+        self.doc_ids = ids
+        self.doc_contents = {d["id"]: d["content"] for d in documents}
+        self._persist()
+
+        return {"success": True, "count": len(documents)}
+
+    def add_documents(self, documents: list[dict]) -> dict:
+        """
+        Append documents to the existing index.
+        Falls back to full index if no index exists yet.
+        """
+        if not documents:
+            return {"success": True, "count": 0}
+
+        if self.vectors is None or len(self.doc_ids) == 0:
+            return self.index_documents(documents)
+
+        ids = [d["id"] for d in documents]
+        contents = [d["content"] for d in documents]
+
+        new_vecs = self._embed(contents)
+
+        self.vectors = np.vstack([self.vectors, new_vecs])
+        self.doc_ids.extend(ids)
+        for d in documents:
+            self.doc_contents[d["id"]] = d["content"]
+        self._persist()
+
+        return {"success": True, "count": len(documents)}
+
+    def search(self, query: str, k: int = 10) -> dict:
+        """
+        Search for documents by cosine similarity.
+        Returns: {"results": [{"id": "...", "score": 0.9, "content": "..."}]}
+        """
+        if self.vectors is None or len(self.doc_ids) == 0:
+            return {"results": []}
+
+        try:
+            q_vec = self._embed([query])  # (1, EMBEDDING_DIM)
+            scores = (self.vectors @ q_vec.T).squeeze()  # (n,)
+
+            top_k = min(k, len(self.doc_ids))
+            top_indices = np.argsort(scores)[::-1][:top_k]
+
+            results = []
+            for idx in top_indices:
+                doc_id = self.doc_ids[idx]
+                results.append({
+                    "id": doc_id,
+                    "score": float(scores[idx]),
+                    "content": self.doc_contents.get(doc_id, ""),
+                })
+
+            return {"results": results}
+        except Exception as e:
+            return {"results": [], "error": str(e)}
+
+    def rerank(self, query: str, documents: list[dict], k: int = 10) -> dict:
+        """
+        Rerank provided documents by embedding similarity (no persistent index used).
+        documents: [{"id": "...", "content": "..."}]
+        """
+        if not documents:
+            return {"results": []}
+
+        try:
+            contents = [d["content"] for d in documents]
+            doc_vecs = self._embed(contents)
+            q_vec = self._embed([query])
+
+            scores = (doc_vecs @ q_vec.T).squeeze()
+            if scores.ndim == 0:
+                scores = scores.reshape(1)
+
+            top_k = min(k, len(documents))
+            top_indices = np.argsort(scores)[::-1][:top_k]
+
+            results = []
+            for idx in top_indices:
+                results.append({
+                    "id": documents[idx]["id"],
+                    "score": float(scores[idx]),
+                    "content": documents[idx]["content"],
+                })
+
+            return {"results": results}
+        except Exception as e:
+            return {"results": [], "error": str(e)}
+
+    def delete_documents(self, doc_ids: list[str]) -> dict:
+        """Remove documents by ID and persist."""
+        if self.vectors is None or len(self.doc_ids) == 0:
+            return {"success": True, "count": 0}
+
+        ids_to_remove = set(doc_ids)
+        keep_mask = [i for i, did in enumerate(self.doc_ids) if did not in ids_to_remove]
+
+        if len(keep_mask) == 0:
+            self.vectors = None
+            self.doc_ids = []
+            self.doc_contents = {}
+        else:
+            self.vectors = self.vectors[keep_mask]
+            self.doc_ids = [self.doc_ids[i] for i in keep_mask]
+            for did in doc_ids:
+                self.doc_contents.pop(did, None)
+
+        self._persist()
+        return {"success": True, "count": len(doc_ids)}
+
+
+def main():
+    """Main loop -- read JSON commands from stdin, write responses to stdout."""
+    index_path = os.environ.get("ENGRAM_INDEX_PATH", os.path.expanduser("~/.engram"))
+    bridge = JinaBridge(index_path)
+
+    # Signal ready
+    print(json.dumps({"status": "ready"}), flush=True)
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            cmd = json.loads(line)
+            action = cmd.get("action")
+
+            if action == "index":
+                result = bridge.index_documents(cmd.get("documents", []))
+            elif action == "add":
+                result = bridge.add_documents(cmd.get("documents", []))
+            elif action == "search":
+                result = bridge.search(cmd.get("query", ""), cmd.get("k", 10))
+            elif action == "rerank":
+                result = bridge.rerank(
+                    cmd.get("query", ""),
+                    cmd.get("documents", []),
+                    cmd.get("k", 10),
+                )
+            elif action == "delete":
+                result = bridge.delete_documents(cmd.get("ids", []))
+            elif action == "ping":
+                result = {"status": "ok"}
+            elif action == "quit":
+                break
+            else:
+                result = {"error": f"Unknown action: {action}"}
+
+            print(json.dumps(result), flush=True)
+
+        except json.JSONDecodeError as e:
+            print(json.dumps({"error": f"Invalid JSON: {e}"}), flush=True)
+        except Exception as e:
+            print(json.dumps({"error": str(e)}), flush=True)
+
+
+if __name__ == "__main__":
+    main()

package/src/retrieval/{colbert.ts → jina.ts}

@@ -1,5 +1,5 @@
 /**
- * ColBERT retriever - TypeScript wrapper for Python bridge
+ * Jina v5 retriever - TypeScript wrapper for Python bridge
  */
 
 import { spawn, ChildProcess } from "child_process";
@@ -11,7 +11,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // Python bridge is in src/, not dist/ - go up from dist/retrieval to project root, then into src/
-const BRIDGE_PATH = path.join(__dirname, "..", "..", "src", "retrieval", "colbert-bridge.py");
+const BRIDGE_PATH = path.join(__dirname, "..", "..", "src", "retrieval", "jina-bridge.py");
 
 export interface Document {
   id: string;
@@ -32,7 +32,7 @@ interface BridgeResponse {
   error?: string;
 }
 
-export class ColBERTRetriever {
+export class JinaRetriever {
   private process: ChildProcess | null = null;
   private readline: Interface | null = null;
   private pendingRequests: Map<number, {
@@ -76,14 +76,20 @@ export class ColBERTRetriever {
 
     this.process.stderr?.on("data", (data) => {
       // Log Python errors for debugging
-      console.error(`[ColBERT] ${data.toString()}`);
+      console.error(`[Jina] ${data.toString()}`);
     });
 
     this.process.on("exit", (code) => {
-      console.error(`[ColBERT] Process exited with code ${code}`);
+      console.error(`[Jina] Process exited with code ${code}`);
       this.ready = false;
       this.process = null;
       this.readline = null;
+
+      // Reject all pending requests
+      for (const [id, { reject }] of this.pendingRequests) {
+        reject(new Error("Bridge process exited"));
+      }
+      this.pendingRequests.clear();
     });
 
     // Wait for ready signal
@@ -109,7 +115,7 @@ export class ColBERTRetriever {
         resolve(response);
       }
     } catch (error) {
-      console.error(`[ColBERT] Failed to parse: ${line}`);
+      console.error(`[Jina] Failed to parse: ${line}`);
     }
   }
 
@@ -120,7 +126,16 @@ export class ColBERTRetriever {
 
     return new Promise((resolve, reject) => {
       const id = this.requestId++;
-      this.pendingRequests.set(id, { resolve, reject });
+
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Bridge request timed out after 30s: ${command.action}`));
+      }, 30_000);
+
+      this.pendingRequests.set(id, {
+        resolve: (value) => { clearTimeout(timeout); resolve(value); },
+        reject: (error) => { clearTimeout(timeout); reject(error); },
+      });
 
       const json = JSON.stringify(command) + "\n";
       this.process!.stdin!.write(json);
@@ -171,7 +186,7 @@ export class ColBERTRetriever {
   }
 
   /**
-   * Rerank documents using ColBERT
+   * Rerank documents using Jina v5
    */
   async rerank(query: string, documents: Document[], k: number = 10): Promise<SearchResult[]> {
     const response = await this.send({
@@ -230,7 +245,7 @@ export class ColBERTRetriever {
 }
 
 /**
- * Fallback retriever when ColBERT is not available
+ * Fallback retriever when Jina is not available
  * Uses simple TF-IDF-like scoring
  */
 export class SimpleRetriever {
@@ -299,17 +314,17 @@ export class SimpleRetriever {
 /**
  * Create the best available retriever
  */
-export async function createRetriever(indexPath: string): Promise<ColBERTRetriever | SimpleRetriever> {
-  const colbert = new ColBERTRetriever(indexPath);
+export async function createRetriever(indexPath: string): Promise<JinaRetriever | SimpleRetriever> {
+  const jina = new JinaRetriever(indexPath);
 
   try {
-    await colbert.start();
-    if (await colbert.ping()) {
-      console.error("[Engram] Using ColBERT retriever");
-      return colbert;
+    await jina.start();
+    if (await jina.ping()) {
+      console.error("[Engram] Using Jina v5 retriever");
+      return jina;
     }
   } catch (error) {
-    console.error("[Engram] ColBERT not available, using simple retriever:", error);
+    console.error("[Engram] Jina not available, using simple retriever:", error);
   }
 
   console.error("[Engram] Using simple fallback retriever");

package/src/web/chat-handler.ts

@@ -1,6 +1,6 @@
 /**
  * Chat Handler for Engram Web Interface
- * Uses Claude Opus 4.5 with tools for entity/memory management
+ * Uses Claude Opus 4.6 with tools for entity/memory management
  */
 
 import Anthropic from "@anthropic-ai/sdk";
@@ -414,7 +414,7 @@ export class ChatHandler {
 
       while (continueLoop) {
         const stream = this.client.messages.stream({
-          model: "claude-opus-4-5-20251101",
+          model: "claude-opus-4-6-20250514",
           max_tokens: 16000,
           system: SYSTEM_PROMPT,
           tools: TOOLS,
@@ -528,7 +528,7 @@ export class ChatHandler {
       }
 
       let response = await this.client.messages.create({
-        model: "claude-opus-4-5-20251101",
+        model: "claude-opus-4-6-20250514",
         max_tokens: 16000,
         system: SYSTEM_PROMPT,
         tools: TOOLS,
@@ -569,7 +569,7 @@ export class ChatHandler {
 
         // Continue the conversation
         response = await this.client.messages.create({
-          model: "claude-opus-4-5-20251101",
+          model: "claude-opus-4-6-20250514",
           max_tokens: 16000,
           system: SYSTEM_PROMPT,
           tools: TOOLS,

package/src/web/server.ts

@@ -223,7 +223,16 @@ export class EngramWebServer {
     url: URL
   ): Promise<void> {
     const method = req.method || "GET";
-    const body = method !== "GET" ? await this.parseBody(req) : null;
+    let body: unknown = null;
+    if (method !== "GET") {
+      try {
+        body = await this.parseBody(req);
+      } catch (e) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e instanceof Error ? e.message : "Invalid request body" }));
+        return;
+      }
+    }
 
     res.setHeader("Content-Type", "application/json");
 
@@ -237,8 +246,10 @@ export class EngramWebServer {
     // GET /api/memories
     if (pathname === "/api/memories" && method === "GET") {
       const query = url.searchParams.get("q");
-      const limit = parseInt(url.searchParams.get("limit") || "50");
-      const offset = parseInt(url.searchParams.get("offset") || "0");
+      const rawLimit = parseInt(url.searchParams.get("limit") || "50");
+      const rawOffset = parseInt(url.searchParams.get("offset") || "0");
+      const limit = Math.max(1, Math.min(500, isNaN(rawLimit) ? 50 : rawLimit));
+      const offset = Math.max(0, isNaN(rawOffset) ? 0 : rawOffset);
 
       if (query) {
         const response = await this.search.search(query, { limit });
@@ -259,7 +270,17 @@ export class EngramWebServer {
     // POST /api/memories
     if (pathname === "/api/memories" && method === "POST") {
       const { content, source, importance } = body as any;
-      const memory = this.db.createMemory(content, source || "web", importance || 0.5);
+      if (!content || typeof content !== "string" || content.trim().length === 0) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "content is required and must be a non-empty string" }));
+        return;
+      }
+      if (importance !== undefined && (typeof importance !== "number" || importance < 0 || importance > 1)) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "importance must be a number between 0 and 1" }));
+        return;
+      }
+      const memory = this.db.createMemory(content, source || "web", importance ?? 0.5);
       await this.search.indexMemory(memory);
       res.writeHead(201);
       res.end(JSON.stringify({ memory }));
@@ -271,6 +292,16 @@ export class EngramWebServer {
     if (memoryMatch && method === "PUT") {
       const id = memoryMatch[1];
       const { content, importance } = body as any;
+      if (content !== undefined && (typeof content !== "string" || content.trim().length === 0)) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "content must be a non-empty string" }));
+        return;
+      }
+      if (importance !== undefined && (typeof importance !== "number" || importance < 0 || importance > 1)) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "importance must be a number between 0 and 1" }));
+        return;
+      }
       const updated = this.db.updateMemory(id, { content, importance });
       if (updated) {
         res.end(JSON.stringify({ memory: updated }));
@@ -444,6 +475,11 @@ export class EngramWebServer {
         res.end(JSON.stringify({ error: "Message is required" }));
         return;
       }
+      if (typeof message !== "string" || message.length > 100_000) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "message must be a string under 100,000 characters" }));
+        return;
+      }
 
       const response = await this.chat.chat(message);
       res.end(JSON.stringify({ response }));
@@ -465,6 +501,11 @@ export class EngramWebServer {
         res.end(JSON.stringify({ error: "Message is required" }));
         return;
       }
+      if (typeof message !== "string" || message.length > 100_000) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "message must be a string under 100,000 characters" }));
+        return;
+      }
 
       // Check if chat is busy
       if (this.chat.isBusy()) {
@@ -612,6 +653,64 @@ export class EngramWebServer {
       return;
     }
 
+    // GET /api/export - export database as CSV
+    if (pathname === "/api/export" && method === "GET") {
+      const format = url.searchParams.get("format") || "csv";
+
+      // Get all data
+      const memories = this.db.getAllMemories();
+      const entities = this.graph.listEntities(undefined, 10000);
+      const digests = this.db.getDigests(undefined, 10000);
+
+      if (format === "csv") {
+        // Build CSV content
+        const csvParts: string[] = [];
+
+        // Memories CSV
+        csvParts.push("=== MEMORIES ===");
+        csvParts.push("id,content,importance,emotional_weight,timestamp,source");
+        for (const m of memories) {
+          const content = m.content.replace(/"/g, '""').replace(/\n/g, ' ');
+          csvParts.push(`"${m.id}","${content}",${m.importance || 0.5},${m.emotional_weight || 0.5},"${m.timestamp.toISOString()}","${m.source || ''}"`);
+        }
+
+        csvParts.push("");
+        csvParts.push("=== ENTITIES ===");
+        csvParts.push("id,name,type");
+        for (const e of entities) {
+          const name = e.name.replace(/"/g, '""');
+          csvParts.push(`"${e.id}","${name}","${e.type}"`);
+        }
+
+        csvParts.push("");
+        csvParts.push("=== DIGESTS ===");
+        csvParts.push("id,level,topic,content,source_count,created_at");
+        for (const d of digests) {
+          const content = d.content.replace(/"/g, '""').replace(/\n/g, ' ');
+          const topic = (d.topic || '').replace(/"/g, '""');
+          csvParts.push(`"${d.id}",${d.level},"${topic}","${content}",${d.source_count},"${d.created_at.toISOString()}"`);
+        }
+
+        const csv = csvParts.join("\n");
+        const timestamp = new Date().toISOString().slice(0, 10);
+
+        res.writeHead(200, {
+          "Content-Type": "text/csv",
+          "Content-Disposition": `attachment; filename="engram-export-${timestamp}.csv"`,
+        });
+        res.end(csv);
+        return;
+      }
+
+      // JSON format (default fallback)
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Content-Disposition": `attachment; filename="engram-export.json"`,
+      });
+      res.end(JSON.stringify({ memories, entities, digests }, null, 2));
+      return;
+    }
+
     // 404 for unknown API routes
     res.writeHead(404);
     res.end(JSON.stringify({ error: "Not found" }));
@@ -651,10 +750,22 @@ export class EngramWebServer {
 
   private parseBody(req: http.IncomingMessage): Promise<unknown> {
     return new Promise((resolve, reject) => {
-      let data = "";
-      req.on("data", (chunk) => (data += chunk));
+      const chunks: Buffer[] = [];
+      let size = 0;
+      const MAX_BODY = 1_048_576; // 1MB
+
+      req.on("data", (chunk: Buffer) => {
+        size += chunk.length;
+        if (size > MAX_BODY) {
+          req.destroy();
+          reject(new Error("Payload too large (max 1MB)"));
+          return;
+        }
+        chunks.push(chunk);
+      });
       req.on("end", () => {
         try {
+          const data = Buffer.concat(chunks).toString();
           resolve(data ? JSON.parse(data) : {});
         } catch (e) {
           reject(e);

package/src/web/static/app.js

@@ -1213,6 +1213,18 @@ clearApiKeyBtn?.addEventListener('click', async () => {
   }
 });
 
+// Export buttons
+const exportCsvBtn = document.getElementById('export-csv');
+const exportJsonBtn = document.getElementById('export-json');
+
+exportCsvBtn?.addEventListener('click', () => {
+  window.location.href = '/api/export?format=csv';
+});
+
+exportJsonBtn?.addEventListener('click', () => {
+  window.location.href = '/api/export?format=json';
+});
+
 // Chat
 chatToggle?.addEventListener('click', toggleChat);
 chatClose?.addEventListener('click', toggleChat);

package/src/web/static/index.html

@@ -308,6 +308,41 @@
                 </select>
               </div>
             </div>
+
+            <div class="settings-section">
+              <div class="settings-section-header">
+                <h3>
+                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                    <path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/>
+                    <polyline points="7 10 12 15 17 10"/>
+                    <line x1="12" y1="15" x2="12" y2="3"/>
+                  </svg>
+                  Data Export
+                </h3>
+              </div>
+              <p class="help-text" style="margin-top: 0; margin-bottom: 20px;">
+                Export your memories, entities, and digests.
+              </p>
+
+              <div class="settings-row" style="gap: 12px;">
+                <button class="btn btn-secondary" id="export-csv">
+                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="width: 16px; height: 16px;">
+                    <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/>
+                    <polyline points="14 2 14 8 20 8"/>
+                    <line x1="16" y1="13" x2="8" y2="13"/>
+                    <line x1="16" y1="17" x2="8" y2="17"/>
+                  </svg>
+                  Export CSV
+                </button>
+                <button class="btn btn-secondary" id="export-json">
+                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="width: 16px; height: 16px;">
+                    <polyline points="16 18 22 12 16 6"/>
+                    <polyline points="8 6 2 12 8 18"/>
+                  </svg>
+                  Export JSON
+                </button>
+              </div>
+            </div>
           </div>
         </section>
       </main>