ltcai 4.1.0 → 4.2.0

package/frontend/openapi.json

@@ -686,6 +686,69 @@
         "title": "CuTypeRequest",
         "type": "object"
       },
+      "DockerPostgresRequest": {
+        "properties": {
+          "consent": {
+            "default": false,
+            "title": "Consent",
+            "type": "boolean"
+          },
+          "dry_run": {
+            "default": false,
+            "title": "Dry Run",
+            "type": "boolean"
+          },
+          "port": {
+            "default": 5432,
+            "title": "Port",
+            "type": "integer"
+          }
+        },
+        "title": "DockerPostgresRequest",
+        "type": "object"
+      },
+      "EncryptedArchiveRequest": {
+        "properties": {
+          "passphrase": {
+            "title": "Passphrase",
+            "type": "string"
+          },
+          "path": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Path"
+          }
+        },
+        "required": [
+          "passphrase"
+        ],
+        "title": "EncryptedArchiveRequest",
+        "type": "object"
+      },
+      "EncryptedRestoreRequest": {
+        "properties": {
+          "passphrase": {
+            "title": "Passphrase",
+            "type": "string"
+          },
+          "path": {
+            "title": "Path",
+            "type": "string"
+          }
+        },
+        "required": [
+          "path",
+          "passphrase"
+        ],
+        "title": "EncryptedRestoreRequest",
+        "type": "object"
+      },
       "ExportRequest": {
         "properties": {
           "filters": {
@@ -1899,6 +1962,29 @@
         "title": "RestoreRequest",
         "type": "object"
       },
+      "SQLiteToPostgresRequest": {
+        "properties": {
+          "dry_run": {
+            "default": true,
+            "title": "Dry Run",
+            "type": "boolean"
+          },
+          "dsn": {
+            "title": "Dsn",
+            "type": "string"
+          },
+          "schema_name": {
+            "default": "lattice_brain",
+            "title": "Schema Name",
+            "type": "string"
+          }
+        },
+        "required": [
+          "dsn"
+        ],
+        "title": "SQLiteToPostgresRequest",
+        "type": "object"
+      },
       "SearchRequest": {
         "properties": {
           "limit": {
@@ -3395,7 +3481,7 @@
   },
   "info": {
     "title": "Lattice AI Server (local)",
-    "version": "4.1.0"
+    "version": "4.2.0"
   },
   "openapi": "3.1.0",
   "paths": {
@@ -5102,6 +5188,94 @@
         "summary": "Agent Runtime Status"
       }
     },
+    "/api/brain/storage": {
+      "get": {
+        "operationId": "brain_storage_status_api_brain_storage_get",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          }
+        },
+        "summary": "Brain Storage Status"
+      }
+    },
+    "/api/brain/storage/migrate-postgres": {
+      "post": {
+        "operationId": "migrate_sqlite_to_postgres_api_brain_storage_migrate_postgres_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/SQLiteToPostgresRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          },
+          "422": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            },
+            "description": "Validation Error"
+          }
+        },
+        "summary": "Migrate Sqlite To Postgres"
+      }
+    },
+    "/api/brain/storage/postgres/docker": {
+      "post": {
+        "operationId": "setup_postgres_docker_api_brain_storage_postgres_docker_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/DockerPostgresRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          },
+          "422": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            },
+            "description": "Validation Error"
+          }
+        },
+        "summary": "Setup Postgres Docker"
+      }
+    },
     "/api/browser/ingest-current-tab": {
       "post": {
         "description": "Ingest a payload captured from the local browser extension.",
@@ -5946,6 +6120,78 @@
         "summary": "Index Status"
       }
     },
+    "/api/knowledge-graph/archive": {
+      "post": {
+        "operationId": "encrypted_archive_api_knowledge_graph_archive_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/EncryptedArchiveRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          },
+          "422": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            },
+            "description": "Validation Error"
+          }
+        },
+        "summary": "Encrypted Archive"
+      }
+    },
+    "/api/knowledge-graph/archive/restore": {
+      "post": {
+        "operationId": "restore_encrypted_archive_api_knowledge_graph_archive_restore_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/EncryptedRestoreRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            },
+            "description": "Successful Response"
+          },
+          "422": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            },
+            "description": "Validation Error"
+          }
+        },
+        "summary": "Restore Encrypted Archive"
+      }
+    },
     "/api/knowledge-graph/backup": {
       "post": {
         "operationId": "backup_graph_api_knowledge_graph_backup_post",

package/frontend/src/api/client.ts

@@ -210,6 +210,9 @@ export const latticeApi = {
   graph: () => get("/knowledge-graph/graph", { nodes: [], edges: [] }),
   graphStats: () => get("/knowledge-graph/stats", { nodes: {}, edges: {}, total_nodes: 0, total_edges: 0 }),
   graphPortability: () => get("/api/knowledge-graph/portability", {}),
+  brainStorage: () => get("/api/brain/storage", {}),
+  dockerPostgres: (body: { consent: boolean; dry_run?: boolean; port?: number }) => post("/api/brain/storage/postgres/docker", body, {}),
+  migratePostgres: (body: { dsn: string; schema_name?: string; dry_run?: boolean }) => post("/api/brain/storage/migrate-postgres", body, {}),
   graphProvenance: (limit = 50) => get("/api/knowledge-graph/provenance", { items: [] }, { limit }),
   graphCoverage: () => get("/knowledge-graph/provenance/coverage", {}),
   graphExport: () => post("/api/knowledge-graph/export", {}, {}),

package/frontend/src/api/openapi.ts

@@ -892,6 +892,57 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/brain/storage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Brain Storage Status */
+        get: operations["brain_storage_status_api_brain_storage_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brain/storage/migrate-postgres": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Migrate Sqlite To Postgres */
+        post: operations["migrate_sqlite_to_postgres_api_brain_storage_migrate_postgres_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brain/storage/postgres/docker": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Setup Postgres Docker */
+        post: operations["setup_postgres_docker_api_brain_storage_postgres_docker_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/browser/ingest-current-tab": {
         parameters: {
             query?: never;
@@ -1212,6 +1263,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/knowledge-graph/archive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Encrypted Archive */
+        post: operations["encrypted_archive_api_knowledge_graph_archive_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/knowledge-graph/archive/restore": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Restore Encrypted Archive */
+        post: operations["restore_encrypted_archive_api_knowledge_graph_archive_restore_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/knowledge-graph/backup": {
         parameters: {
             query?: never;
@@ -5712,6 +5797,38 @@ export interface components {
             /** Text */
             text: string;
         };
+        /** DockerPostgresRequest */
+        DockerPostgresRequest: {
+            /**
+             * Consent
+             * @default false
+             */
+            consent: boolean;
+            /**
+             * Dry Run
+             * @default false
+             */
+            dry_run: boolean;
+            /**
+             * Port
+             * @default 5432
+             */
+            port: number;
+        };
+        /** EncryptedArchiveRequest */
+        EncryptedArchiveRequest: {
+            /** Passphrase */
+            passphrase: string;
+            /** Path */
+            path?: string | null;
+        };
+        /** EncryptedRestoreRequest */
+        EncryptedRestoreRequest: {
+            /** Passphrase */
+            passphrase: string;
+            /** Path */
+            path: string;
+        };
         /** ExportRequest */
         ExportRequest: {
             /** Filters */
@@ -6280,6 +6397,21 @@ export interface components {
              */
             verify: boolean;
         };
+        /** SQLiteToPostgresRequest */
+        SQLiteToPostgresRequest: {
+            /**
+             * Dry Run
+             * @default true
+             */
+            dry_run: boolean;
+            /** Dsn */
+            dsn: string;
+            /**
+             * Schema Name
+             * @default lattice_brain
+             */
+            schema_name: string;
+        };
         /** SearchRequest */
         SearchRequest: {
             /**
@@ -8576,6 +8708,92 @@ export interface operations {
             };
         };
     };
+    brain_storage_status_api_brain_storage_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    migrate_sqlite_to_postgres_api_brain_storage_migrate_postgres_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SQLiteToPostgresRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    setup_postgres_docker_api_brain_storage_postgres_docker_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DockerPostgresRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     ingest_current_tab_api_browser_ingest_current_tab_post: {
         parameters: {
             query?: never;
@@ -9252,6 +9470,72 @@ export interface operations {
             };
         };
     };
+    encrypted_archive_api_knowledge_graph_archive_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedArchiveRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    restore_encrypted_archive_api_knowledge_graph_archive_restore_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedRestoreRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     backup_graph_api_knowledge_graph_backup_post: {
         parameters: {
             query?: never;

package/frontend/src/pages/System.tsx

@@ -279,6 +279,14 @@ function SettingsPanel() {
   const health = useQuery({ queryKey: ["health"], queryFn: latticeApi.health });
   const sys = useQuery({ queryKey: ["sysinfo"], queryFn: latticeApi.sysinfo });
   const comp = useQuery({ queryKey: ["computerMemory"], queryFn: latticeApi.computerMemory });
+  const storage = useQuery({ queryKey: ["brainStorage"], queryFn: latticeApi.brainStorage });
+  const [dsn, setDsn] = React.useState("");
+  const [schema, setSchema] = React.useState("lattice_brain");
+  const [dockerConsent, setDockerConsent] = React.useState(false);
+  const docker = useMutation({ mutationFn: (consent: boolean) => latticeApi.dockerPostgres({ consent, dry_run: !consent, port: 5432 }) });
+  const migration = useMutation({
+    mutationFn: () => latticeApi.migratePostgres({ dsn, schema_name: schema || "lattice_brain", dry_run: true }),
+  });
   return (
     <div className="grid gap-4 xl:grid-cols-3">
       <Card>
@@ -300,6 +308,32 @@ function SettingsPanel() {
       <DataPanel title="Host telemetry" result={sys.data}>
         {(data) => <JsonView value={data} />}
       </DataPanel>
+      <DataPanel title="Brain storage" result={storage.data} className="xl:col-span-3">
+        {(data) => <JsonView value={data} />}
+      </DataPanel>
+      <Card className="xl:col-span-3">
+        <CardHeader>
+          <CardTitle>Postgres scale mode</CardTitle>
+          <CardDescription>Opt-in migration and Docker setup; SQLite remains the default.</CardDescription>
+        </CardHeader>
+        <CardContent className="grid gap-3">
+          <div className="grid gap-2 sm:grid-cols-[1fr_220px]">
+            <Input value={dsn} onChange={(e) => setDsn(e.target.value)} placeholder="postgresql://user:pass@127.0.0.1:5432/lattice_brain" />
+            <Input value={schema} onChange={(e) => setSchema(e.target.value)} placeholder="schema" />
+          </div>
+          <div className="flex flex-wrap gap-2">
+            <Button variant="outline" onClick={() => docker.mutate(false)} disabled={docker.isPending}>Docker plan</Button>
+            <label className="flex items-center gap-2 rounded-md border border-border px-3 py-2 text-sm">
+              <input type="checkbox" checked={dockerConsent} onChange={(e) => setDockerConsent(e.target.checked)} />
+              Consent to start Docker
+            </label>
+            <Button onClick={() => docker.mutate(true)} disabled={!dockerConsent || docker.isPending}>Start Docker</Button>
+            <Button variant="outline" onClick={() => migration.mutate()} disabled={!dsn || migration.isPending}>Plan migration</Button>
+          </div>
+          {docker.data ? <JsonView value={docker.data.data || docker.data.error} /> : null}
+          {migration.data ? <JsonView value={migration.data.data || migration.data.error} /> : null}
+        </CardContent>
+      </Card>
       <DataPanel title="Computer memory" result={comp.data} className="xl:col-span-3">
         {(data) => (
           <div className="space-y-3">

package/kg_schema.py

@@ -1,3 +1,3 @@
 """Compatibility shim for the v4 Knowledge Graph schema."""
 
-from latticeai.brain.schema import *  # noqa: F403,F401
+from lattice_brain.schema import *  # noqa: F403,F401

package/knowledge_graph.py

@@ -1,10 +1,10 @@
-"""Compatibility shim for the v4 brain store.
+"""Compatibility shim for the v4.2 lattice-brain store.
 
-The implementation now lives under :mod:`latticeai.brain`. Root imports are
+The implementation now lives under :mod:`lattice_brain`. Root imports are
 kept for older integrations and tests.
 """
 
-from latticeai.brain._kg_common import (  # noqa: F401
+from lattice_brain._kg_common import (  # noqa: F401
     EDGE_VERB,
     GRAPH_SCHEMA_VERSION,
     LOCAL_CODE_EXTENSIONS,
@@ -24,7 +24,7 @@ from latticeai.brain._kg_common import (  # noqa: F401
     _slug,
     set_llm_router,
 )
-from latticeai.brain.store import KnowledgeGraphStore
+from lattice_brain.store import KnowledgeGraphStore
 
 __all__ = [
     "KnowledgeGraphStore",