Add memory

Author: slimslenderslacks

functions/memory/Dockerfile

@@ -0,0 +1,33 @@
+
+# syntax = docker/dockerfile:1.4
+FROM nixos/nix:2.21.1@sha256:3f6c77ee4d2c82e472e64e6cd7087241dc391421a0b42c22e6849c586d5398d9 AS builder
+
+WORKDIR /tmp/build
+RUN mkdir /tmp/nix-store-closure
+
+# ignore SC2046 because the output of nix-store -qR will never have spaces - this is safe here
+# hadolint ignore=SC2046
+RUN --mount=type=cache,target=/nix,from=nixos/nix:2.21.1,source=/nix \
+    --mount=type=cache,target=/root/.cache \
+    --mount=type=bind,target=/tmp/build \
+    <<EOF
+  nix \
+    --extra-experimental-features "nix-command flakes" \
+    --option filter-syscalls false \
+    --extra-trusted-substituters "https://cache.iog.io" \
+    --extra-trusted-public-keys "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" \
+    --show-trace \
+    --log-format raw \
+    build . --out-link /tmp/output/result
+  cp -R $(nix-store -qR /tmp/output/result) /tmp/nix-store-closure
+EOF
+
+FROM babashka/babashka:latest@sha256:9e0381fc4c78ee6ff12fd8836352cf343afba289aceb77e36129d92f30a92cc7
+
+WORKDIR /app
+
+COPY --from=builder /tmp/nix-store-closure /nix/store
+COPY --from=builder /tmp/output/ /app/
+
+ENTRYPOINT ["/app/result/bin/entrypoint"]
+CMD ["--help"]

functions/memory/flake.lock

@@ -0,0 +1,43 @@
+{
+  description = "{{tool}}";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils, ...}@inputs:
+
+    flake-utils.lib.eachDefaultSystem
+      (system:
+        let
+          pkgs = import nixpkgs {
+            inherit system;
+          };
+
+        in rec
+        {
+          packages = rec {
+
+            # this derivation just contains the init.clj script
+            scripts = pkgs.stdenv.mkDerivation {
+              name = "scripts";
+              src = ./.;
+              installPhase = ''
+                cp init.clj $out
+              '';
+            };
+
+            run-entrypoint = pkgs.writeShellScriptBin "entrypoint" ''
+              export SSL_CERT_FILE=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
+              /usr/local/bin/bb ${scripts} "$@"
+            '';
+
+            default = pkgs.buildEnv {
+              name = "bb";
+              paths = [ run-entrypoint ];
+            };
+          };
+        });
+}
+

functions/memory/flake.nix

@@ -0,0 +1,130 @@
+(ns init
+  (:require
+   [cheshire.core :as json]
+   [clojure.java.io :as io]
+   [clojure.string :as string]))
+
+(defn- item [graph item]
+  (let [{:keys [type] :as m} (json/parse-string item keyword)]
+    (case type
+      "entity" (update graph :entities (fnil conj []) m)
+      "relation" (update graph :relations (fnil conj []) m))))
+
+(def db-file "/memory/memory.json")
+#_(def db-file "memory.json")
+
+(defn- load-graph []
+  (try
+    (->> (line-seq (io/reader db-file))
+         (reduce item {}))
+    (catch Throwable t
+      {:entities []
+       :relations []})))
+
+(defn- save-graph [graph]
+  (spit
+   db-file
+   (->>
+    (concat
+     (->> (:entities graph)
+          (map #(assoc % :type "entity"))
+          (map json/generate-string))
+     (->> (:relations graph)
+          (map #(assoc % :type "relation"))
+          (map json/generate-string)))
+    (string/join "\n"))))
+
+(comment
+  (save-graph
+    (load-graph)))
+
+(defn- entity? [graph e]
+  (some #(= (:name e) (:name %)) (:entities graph)))
+
+;; must have names
+(defn create-entities [{:keys [entities]}]
+  (let [graph (load-graph)
+        new-entities (->> entities
+                          (filter
+                           (complement (partial entity? graph))))]
+    (save-graph (update graph :entities concat new-entities))
+    new-entities))
+
+(comment
+  (create-entities {:entities [{:name "me"} {:name "rod"}]}))
+
+(defn- relation? [graph e]
+  (some
+   #(and
+     (= (:from e) (:from %))
+     (= (:to e) (:to %))
+     (= (:relationType e) (:relationType %)))
+   (:relations graph)))
+
+;; must have from, to, and relationType
+(defn create-relations [{:keys [relations]}]
+  (let [graph (load-graph)
+        new-relations (->> relations
+                           (filter
+                            (complement
+                              (partial relation? graph))))]
+    (save-graph (update graph :relations (fnil concat []) new-relations))
+    new-relations))
+
+(comment
+  (create-relations {:relations [{:from "me" :to "rod" :relationType "friend"}]})
+  (load-graph))
+
+(defn- add-observation [agg {:keys [entityName contents]}]
+  (if-let [entity (first (filter #(= entityName (:name %)) (-> agg :graph :entities)))]
+    (let [new-observations []
+          n 0]
+      (-> agg
+          (update :results conj {:entityName entityName :addedObservations new-observations})
+          (update :graph (update-in [:entities n :observations] (fnil concat []) new-observations))))
+    agg))
+
+;; observations are a list of entityName contents maps - contents are string arrays
+(defn add-observations [{:keys [observations]}]
+  (let [graph (load-graph)
+        {:keys [results graph]}
+        (->> observations
+             (reduce
+              add-observation
+              {:graph graph :results []}))]
+    (save-graph graph)
+    results))
+
+(comment
+  (add-observations 
+    {:observations 
+     [{:entityName "me" :contents ["my personal email is [email protected]"]} 
+      {:entityName "rod" :contents ["Rod is in Sydney, Australia"]}]})
+  (load-graph))
+
+(defn delete-entities [{:keys [entityNames]}]
+  (save-graph
+   (-> (load-graph)
+       (update :entities (fn [entities] (filter entities)))
+       (update :relations (fn [relations] (filter relations))))))
+(defn delete-observations [{:keys [deletions]}]
+  (save-graph
+   (-> (load-graph)
+       (update :entities (fn [entities])))))
+(defn delete-relations [{:keys [relations]}]
+  (save-graph
+   (-> (load-graph)
+       (update :relations (fn [entities])))))
+(defn search-nodes [{:keys [query]}])
+(defn open-nodes [{:keys [names]}])
+
+(try
+  (let [[s raw-json-string] *command-line-args*
+        m (json/parse-string raw-json-string true)]
+    (println
+     ((get (ns-publics 'init) (symbol s)) m)))
+  (catch Throwable t
+    (binding [*out* *err*]
+      (println (str "Error: " (.getMessage t)))
+      (System/exit 1))))
+

functions/memory/init.clj

@@ -0,0 +1,24 @@
+
+```sh
+docker build -t vonwig/memory:latest .
+```
+
+```sh
+docker run -it --rm \
+           -v ~/slimslenderslacks/flask-nix-example:/project \
+           -v mcp-memory:/memory \
+           vonwig/memory:latest \
+           'create-entities' \
+           '{"entities": [{"name": "me"}]}'
+```
+
+```sh
+docker buildx build \
+    --builder hydrobuild \
+    --platform linux/amd64,linux/arm64 \
+    --tag vonwig/memory:latest \
+    --file Dockerfile \
+    --push .
+
+```
+

functions/memory/memory.json

@@ -226,3 +226,7 @@ registry:
       to make edits and run tools in an isolated sandbox. 
     ref: github:docker/labs-ai-tools-for-devs?path=prompts/lorax/speculative.md
     icon: https://vonwig.github.io/prompts.docs/img/speculative_hu15687469033092380316.webp
+  memory:
+    description: give your MCP client a memory system
+    ref: github:docker/labs-ai-tools-for-devs?path=prompts/examples/mcp-memory.md
+    icon: https://cdn.jsdelivr.net/npm/simple-icons@v7/icons/knowledgebase.svg