@dbx-tools/appkit-graphiti 0.6.114 → 0.6.116

package/README.md

@@ -5,46 +5,51 @@ AppKit process plugin for the Python `dbx-tools-graphiti` MCP runtime.
 ## Key features
 
 - starts Graphiti as a supervised AppKit sidecar;
-- inherits the Lakebase environment resolved by `@dbx-tools/appkit` and native
-  `lakebase()`, enabling the Python Postgres write journal automatically;
-- starts mise-managed Caddy on `DATABRICKS_APP_PORT`;
-- routes `/graphiti/*` to Graphiti and all other traffic to AppKit;
-- selects a free loopback port for Graphiti unless one is explicitly configured;
-- discovers the upstream MCP tools and exposes them through
-  `plugins.graphiti?.toolkit()` for Mastra and AppKit agents;
-- binds both child processes to the shared concurrently-style supervisor so
-  signals propagate and any child exit tears down the app;
-- exposes the internal AppKit port and public MCP path through plugin exports.
+- enables the Python Postgres write journal when the app supplies Lakebase or
+  PostgreSQL connection environment;
+- starts an internal loopback Caddy proxy in front of upstream Graphiti, then
+  republishes the allowed tools through AppKit at `/api/graphiti/mcp`;
+- derives a stable private Graphiti group from the AppKit user or Mastra memory
+  resource id, overriding every caller-supplied group;
+- exposes only operations that can be constrained to that group and removes
+  UUID arguments that could reference another user's graph objects;
+- selects separate free loopback ports for Graphiti, LiteLLM, and Caddy unless
+  they are explicitly configured;
+- exposes the user-scoped tools through `plugins.graphiti?.toolkit()` for
+  `@dbx-tools/appkit-mastra` agents;
+- runs Graphiti and Caddy under `concurrently`, while the Python launcher runs
+  Graphiti and LiteLLM under Honcho;
+- propagates termination signals through both supervisors, which escalate
+  unresponsive process groups to `SIGKILL`;
+- exposes the MCP path through plugin exports.
 
 ## Why use this over native AppKit
 
-AppKit has no Graphiti or embedded MCP sidecar. This package owns AppKit process
-lifecycle and single-port routing while `dbx-tools-graphiti` owns
-Graphiti, Neo4j, LiteLLM, and Postgres recovery.
+AppKit has no Graphiti or embedded MCP sidecar. This package owns AppKit routes
+and process lifecycle while `dbx-tools-graphiti` owns Graphiti, Neo4j, LiteLLM,
+and Postgres recovery.
 
 ## Register
 
-Install `dbx-tools-graphiti` in the app's Python dependencies, then register
-native `lakebase()` before the Graphiti plugin:
+Install `dbx-tools-graphiti` in the app's Python dependencies and register the
+plugin:
 
 ```ts
-import { lakebase, server } from "@databricks/appkit";
+import { server } from "@databricks/appkit";
 import { appkit } from "@dbx-tools/appkit";
-import { config as graphitiConfig, plugin as graphitiPlugin } from "@dbx-tools/appkit-graphiti";
-
-const graphiti = graphitiConfig.resolveGraphitiConfig();
+import { plugin as graphitiPlugin } from "@dbx-tools/appkit-graphiti";
 
 await appkit.createApp({
-  plugins: [
-    server({ host: "127.0.0.1", port: graphiti.appPort }),
-    lakebase(),
-    graphitiPlugin.graphiti(graphiti),
-  ],
+  plugins: [server(), graphitiPlugin.graphiti()],
 });
 ```
 
-The public MCP endpoint is `/graphiti/mcp/`. Caddy listens on the platform's
-`DATABRICKS_APP_PORT`; AppKit and Graphiti remain loopback-only.
+AppKit continues to listen on `DATABRICKS_APP_PORT`. The plugin adds a
+user-scoped MCP server at `/api/graphiti/mcp`; Graphiti, LiteLLM, and Caddy
+remain loopback-only. The plugin's manifest declares the Lakebase resource
+requirements used by generated deployments, so Graphiti does not require a
+separate `lakebase()` plugin. Local callers must still supply a Lakebase or
+PostgreSQL connection environment to enable the journal.
 
 Add the MCP tools to a Mastra agent with:
 
@@ -54,27 +59,36 @@ tools(plugins) {
 }
 ```
 
+The same resource id that scopes Mastra memory scopes every Graphiti operation
+invoked as an agent tool. Direct MCP requests use the forwarded AppKit user id,
+falling back to AppKit's service identity in local development. The plugin
+hashes that identity before using it as a Graphiti group id. Model or MCP input
+cannot choose `group_id` or `group_ids`.
+
+The scoped surface includes memory ingestion, node/fact search, episode listing,
+saga summaries, community building, triplet insertion, and status. UUID-only
+read/delete operations and graph clearing are omitted from the agent and public
+MCP surfaces.
+
 ## Configuration
 
 Plugin config overrides environment values:
 
-- `publicPort` / `DATABRICKS_APP_PORT`: Caddy's public port, default `8000`;
-- `appPort` / `GRAPHITI_APP_PORT`: AppKit's internal port, default public + 1;
 - `graphitiPort` / `GRAPHITI_PORT`: Graphiti's internal port; a free loopback
   port is selected automatically when omitted;
 - `litellmPort` / `LITELLM_PORT`: the managed LiteLLM port; a separate free
   loopback port is selected automatically so another local proxy cannot be
   mistaken for Graphiti's model backend;
-- `routePrefix` / `GRAPHITI_ROUTE_PREFIX`: public Graphiti prefix, default
-  `/graphiti`;
+- `proxyPort` / `PROXY_PORT`: Caddy's internal port; a third free loopback port
+  is selected automatically when omitted;
 - `python` / `PYTHON`: Python executable, default `python3`;
 - `journalNamespace` / `JOURNAL_NAMESPACE`: Postgres journal namespace, default
-  `DATABRICKS_APP_NAME` then `default`.
+  `DATABRICKS_APP_NAME`, then the detected project name, then `default`.
 
 The app must package both Node and Python dependencies. Databricks Apps supports
-this directly with `package.json` plus `requirements.txt`.
+this directly with `package.json` plus `pyproject.toml` or `requirements.txt`.
 
 ## Modules
 
-- `config` resolves ports, process command, route prefix, and journal namespace;
+- `config` resolves sidecar ports, the Python command, and journal namespace;
 - `plugin` starts and supervises Graphiti and Caddy.

package/lib/src/config.d.ts

@@ -1,53 +1,41 @@
 /**
- * AppKit Graphiti sidecar ports, route prefix, and Python command.
+ * AppKit Graphiti sidecar ports and Python command.
  *
  * @module
  */
 import { type BasePluginConfig } from "@databricks/appkit";
 export interface GraphitiPluginConfig extends BasePluginConfig {
-    publicPort?: number;
-    appPort?: number;
     graphitiPort?: number;
     litellmPort?: number;
-    routePrefix?: string;
+    proxyPort?: number;
     python?: string;
     journalNamespace?: string;
 }
 export interface ResolvedGraphitiPluginConfig extends GraphitiPluginConfig {
-    publicPort: number;
-    appPort: number;
     graphitiPort: number;
     litellmPort: number;
-    routePrefix: string;
+    proxyPort: number;
     python: string;
     journalNamespace: string;
 }
 export declare const GRAPHITI_CONFIG_SCHEMA: {
     type: "object";
     properties: {
-        publicPort: {
-            type: "integer";
-            minimum: number;
-            maximum: number;
-        };
-        appPort: {
+        graphitiPort: {
             type: "integer";
             minimum: number;
             maximum: number;
         };
-        graphitiPort: {
+        litellmPort: {
             type: "integer";
             minimum: number;
             maximum: number;
         };
-        litellmPort: {
+        proxyPort: {
             type: "integer";
             minimum: number;
             maximum: number;
         };
-        routePrefix: {
-            type: "string";
-        };
         python: {
             type: "string";
         };
@@ -59,5 +47,3 @@ export declare const GRAPHITI_CONFIG_SCHEMA: {
 };
 /** Resolve plugin config over exact environment values and stable defaults. */
 export declare function resolveGraphitiConfig(config?: GraphitiPluginConfig): ResolvedGraphitiPluginConfig;
-/** Return the internal port an AppKit `server()` plugin should bind. */
-export declare function appPort(config?: GraphitiPluginConfig): number;

package/lib/src/config.js

@@ -1,18 +1,16 @@
 /**
- * AppKit Graphiti sidecar ports, route prefix, and Python command.
+ * AppKit Graphiti sidecar ports and Python command.
  *
  * @module
  */
 import { ConfigurationError } from "@databricks/appkit";
-import { config as coreConfig } from "@dbx-tools/core";
+import { config as coreConfig, project as coreProject } from "@dbx-tools/core";
 export const GRAPHITI_CONFIG_SCHEMA = {
     type: "object",
     properties: {
-        publicPort: { type: "integer", minimum: 1, maximum: 65535 },
-        appPort: { type: "integer", minimum: 1, maximum: 65535 },
         graphitiPort: { type: "integer", minimum: 1, maximum: 65535 },
         litellmPort: { type: "integer", minimum: 1, maximum: 65535 },
-        routePrefix: { type: "string" },
+        proxyPort: { type: "integer", minimum: 1, maximum: 65535 },
         python: { type: "string" },
         journalNamespace: { type: "string" },
     },
@@ -20,41 +18,25 @@ export const GRAPHITI_CONFIG_SCHEMA = {
 };
 /** Resolve plugin config over exact environment values and stable defaults. */
 export function resolveGraphitiConfig(config = {}) {
-    const publicPort = coreConfig.port(config.publicPort, "DATABRICKS_APP_PORT", 8000, coreConfig.ENV_ONLY);
-    const appPort = coreConfig.port(config.appPort, "GRAPHITI_APP_PORT", publicPort + 1, coreConfig.ENV_ONLY);
     const graphitiPort = coreConfig.port(config.graphitiPort, "GRAPHITI_PORT", 0, coreConfig.ENV_ONLY);
     const litellmPort = coreConfig.port(config.litellmPort, "LITELLM_PORT", 0, coreConfig.ENV_ONLY);
-    const configuredPorts = [publicPort, appPort, graphitiPort, litellmPort].filter(Boolean);
+    const proxyPort = coreConfig.port(config.proxyPort, "PROXY_PORT", 0, coreConfig.ENV_ONLY);
+    const configuredPorts = [graphitiPort, litellmPort, proxyPort].filter(Boolean);
     if (new Set(configuredPorts).size !== configuredPorts.length) {
-        throw new ConfigurationError("Graphiti public, AppKit, and sidecar ports must be distinct");
+        throw new ConfigurationError("Graphiti sidecar ports must be distinct");
     }
-    const routePrefix = normalizeRoutePrefix(config.routePrefix ??
-        coreConfig.text("GRAPHITI_ROUTE_PREFIX", coreConfig.ENV_ONLY) ??
-        "/graphiti");
     const python = config.python ?? coreConfig.text("PYTHON", coreConfig.ENV_ONLY)?.trim() ?? "python3";
     const journalNamespace = config.journalNamespace ??
         coreConfig.text("JOURNAL_NAMESPACE", coreConfig.ENV_ONLY)?.trim() ??
         process.env.DATABRICKS_APP_NAME?.trim() ??
+        coreProject.name() ??
         "default";
     return {
-        publicPort,
-        appPort,
         graphitiPort,
         litellmPort,
-        routePrefix,
+        proxyPort,
         python,
         journalNamespace,
     };
 }
-/** Return the internal port an AppKit `server()` plugin should bind. */
-export function appPort(config = {}) {
-    return resolveGraphitiConfig(config).appPort;
-}
-function normalizeRoutePrefix(value) {
-    const normalized = `/${value.trim().replace(/^\/+|\/+$/g, "")}`;
-    if (normalized === "/") {
-        throw new ConfigurationError("Graphiti routePrefix must contain a path segment");
-    }
-    return normalized;
-}
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/plugin.d.ts

@@ -1,6 +1,7 @@
-import { Plugin, type PluginManifest, type ResourceRequirement } from "@databricks/appkit";
+import { Plugin, type IAppRouter, type PluginManifest, type ResourceRequirement } from "@databricks/appkit";
 import { type GraphitiPluginConfig } from "./config.ts";
 interface ToolkitEntry {
+    readonly __toolkitRef: true;
     pluginName: string;
     localName: string;
     def: {
@@ -8,29 +9,40 @@ interface ToolkitEntry {
         description: string;
         parameters: unknown;
     };
+    annotations: {
+        effect: "read" | "write";
+        requiresUserContext: true;
+    };
 }
 export declare class GraphitiPlugin extends Plugin<GraphitiPluginConfig> {
     static manifest: PluginManifest<"graphiti">;
     static getResourceRequirements(): ResourceRequirement[];
     private readonly logger;
-    private children;
+    private commands;
     private mcp?;
+    private mcpServers;
+    private mcpServerSweep?;
     private mcpTools;
     private resolved?;
+    private setupComplete;
+    private supervision?;
     private stopping;
     setup(): Promise<void>;
+    injectRoutes(router: IAppRouter): void;
     abortActiveOperations(): void;
+    shutdown(): Promise<void>;
     exports(): {
-        appPort: number;
-        graphitiPort: number;
-        litellmPort: number;
         mcpPath: string;
-        publicPort: number;
-        routePrefix: string;
     };
     toolkit(): Record<string, ToolkitEntry>;
-    executeAgentTool(name: string, args: unknown, signal?: AbortSignal): Promise<unknown>;
-    private stopGraphiti;
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal, context?: {
+        resourceId?: string;
+    }): Promise<unknown>;
+    private forwardMcp;
+    private mcpServer;
+    private onSupervisorExit;
+    private stopSidecars;
+    private closeIdleMcpServers;
 }
 export declare const graphiti: import("@databricks/appkit").ToPlugin<typeof GraphitiPlugin, GraphitiPluginConfig, "graphiti">;
 export {};