@dxos/assistant-toolkit 0.8.4-main.c85a9c8dae → 0.8.4-main.dfabb4ec29

package/dist/lib/neutral/index.mjs

@@ -1,1589 +1,575 @@
+import {
+  AgentPrompt
+} from "./chunk-GV66MKAQ.mjs";
+import {
+  DeleteMemory,
+  QueryMemories,
+  SaveMemory
+} from "./chunk-EJAQUAKM.mjs";
+import {
+  EnableBlueprints,
+  QueryBlueprints,
+  UpdateBlueprints
+} from "./chunk-TO5IX24K.mjs";
+import {
+  AgentRules,
+  CreateAgent,
+  SyncTriggers
+} from "./chunk-XUF53B6B.mjs";
+import {
+  SyncIssues,
+  syncObjects
+} from "./chunk-ROMZO4CB.mjs";
+import {
+  UpdateTasks
+} from "./chunk-FIGO6CA6.mjs";
+import {
+  Fetch
+} from "./chunk-WLR3BGO4.mjs";
+import {
+  ContextAdd,
+  ContextRemove,
+  Load,
+  ObjectCreate,
+  ObjectDelete,
+  ObjectUpdate,
+  Query,
+  RelationCreate,
+  RelationDelete,
+  SchemaAdd,
+  SchemaList,
+  TagAdd,
+  TagRemove
+} from "./chunk-IKBIORQX.mjs";
+import {
+  FetchMessages
+} from "./chunk-ZFXLTBZG.mjs";
+import {
+  AgentBlueprintHandlers,
+  blueprint_default
+} from "./chunk-QO5SU37C.mjs";
+import {
+  AddArtifact,
+  AgentWorker,
+  GetContext,
+  Qualifier
+} from "./chunk-246ACKSH.mjs";
+import {
+  Agent_exports,
+  McpServer_exports,
+  Plan_exports
+} from "./chunk-P4ZMYO4K.mjs";
+import {
+  Chat_exports
+} from "./chunk-NR3GTWRC.mjs";
+import {
+  Memory_exports
+} from "./chunk-KGU725LW.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
 
-// src/blueprints/design/blueprint.ts
-import { ToolId } from "@dxos/ai";
-import { Blueprint as Blueprint2 } from "@dxos/blueprints";
-import { Ref as Ref5 } from "@dxos/echo";
-import { Text as Text2 } from "@dxos/schema";
-import { trim as trim2 } from "@dxos/util";
-
-// src/blueprints/markdown/blueprint.ts
-import { Blueprint } from "@dxos/blueprints";
-import { Ref as Ref4 } from "@dxos/echo";
+// src/blueprints/discord/blueprint.ts
+import { Blueprint } from "@dxos/compute";
+import { Ref } from "@dxos/echo";
 import { Text } from "@dxos/schema";
 import { trim } from "@dxos/util";
 
-// src/blueprints/markdown/functions/create.ts
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { Database, Ref } from "@dxos/echo";
-import { defineFunction } from "@dxos/functions";
-import { Markdown } from "@dxos/plugin-markdown/types";
-var create_default = defineFunction({
-  key: "dxos.org/function/markdown/create",
-  name: "Create markdown document",
-  description: "Creates a new markdown document.",
-  inputSchema: Schema.Struct({
-    name: Schema.String.annotations({
-      description: "Name of the document."
-    }),
-    content: Schema.String.annotations({
-      description: "Content of the document."
-    })
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { name, content } }) {
-    const doc = yield* Database.add(Markdown.make({
-      name,
-      content
-    }));
-    return {
-      document: Ref.make(doc)
-    };
-  })
-});
-
-// src/blueprints/markdown/functions/read.ts
-import * as Effect2 from "effect/Effect";
-import * as Schema2 from "effect/Schema";
-import { Database as Database2, Ref as Ref2 } from "@dxos/echo";
-import { defineFunction as defineFunction2 } from "@dxos/functions";
-import { Markdown as Markdown2 } from "@dxos/plugin-markdown/types";
-var read_default = defineFunction2({
-  key: "dxos.org/function/markdown/read",
-  name: "Read markdown document",
-  description: "Read markdown document. Note that result is a snapshot in time, and might have changed since the document was last read.",
-  inputSchema: Schema2.Struct({
-    document: Ref2.Ref(Markdown2.Document).annotations({
-      description: "The document to read."
-    })
-  }),
-  outputSchema: Schema2.Struct({
-    content: Schema2.String
-  }),
-  handler: Effect2.fn(function* ({ data: { document } }) {
-    const { content } = yield* document.pipe(Database2.load, Effect2.flatMap((doc) => doc.content.pipe(Database2.load)));
-    return {
-      content
-    };
-  })
-});
+// src/blueprints/discord/functions/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var DiscordHandlers = OperationHandlerSet.lazy(() => import("./fetch-messages-QOBBCTGC.mjs"));
 
-// src/blueprints/markdown/functions/update.ts
-import * as Effect3 from "effect/Effect";
-import * as Schema3 from "effect/Schema";
-import { Database as Database3, Obj, Ref as Ref3 } from "@dxos/echo";
-import { defineFunction as defineFunction3 } from "@dxos/functions";
-import { Markdown as Markdown3 } from "@dxos/plugin-markdown/types";
-var update_default = defineFunction3({
-  key: "dxos.org/function/markdown/update",
-  name: "Update markdown",
-  description: "Updates the entire contents of the markdown document.",
-  inputSchema: Schema3.Struct({
-    doc: Ref3.Ref(Markdown3.Document).annotations({
-      description: "The ID of the document to write."
-    }),
-    content: Schema3.String.annotations({
-      description: "New content to write to the document."
-    })
-  }),
-  outputSchema: Schema3.Void,
-  handler: Effect3.fn(function* ({ data: { doc, content } }) {
-    const document = yield* Database3.load(doc);
-    const text = yield* Database3.load(document.content);
-    Obj.change(text, (t) => {
-      t.content = content;
-    });
-  })
-});
+// src/blueprints/discord/blueprint.ts
+var BLUEPRINT_KEY = "org.dxos.blueprint.discord";
+var instructions = trim`
+  You are able to fetch messages from Discord servers.
 
-// src/blueprints/markdown/functions/index.ts
-var MarkdownFunctions = {
-  Create: create_default,
-  Read: read_default,
-  Update: update_default
-};
+  Known servers:
 
-// src/blueprints/markdown/blueprint.ts
-var BLUEPRINT_KEY = "dxos.org/blueprint/markdown";
-var instructions = trim`
-  You read, write & create markdown documents.
+  DXOS serverId: 837138313172353095
 `;
-var functions = Object.values(MarkdownFunctions);
 var make = () => Blueprint.make({
   key: BLUEPRINT_KEY,
-  name: "Markdown",
-  description: "Work with markdown documents.",
+  name: "Discord",
+  description: "Discord integration.",
   instructions: {
-    source: Ref4.make(Text.make(instructions))
+    source: Ref.make(Text.make({
+      content: instructions
+    }))
   },
   tools: Blueprint.toolDefinitions({
-    functions
+    operations: [
+      FetchMessages
+    ]
   })
 });
 var blueprint = {
   key: BLUEPRINT_KEY,
-  functions,
   make
 };
-var blueprint_default = blueprint;
+var blueprint_default2 = blueprint;
+
+// src/blueprints/linear/blueprint.ts
+import { Blueprint as Blueprint2 } from "@dxos/compute";
+import { Ref as Ref2 } from "@dxos/echo";
+import { Text as Text2 } from "@dxos/schema";
+import { trim as trim2 } from "@dxos/util";
+
+// src/blueprints/linear/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/compute";
+var LinearHandlers = OperationHandlerSet2.lazy(() => import("./sync-issues-4YE5XAK5.mjs"));
 
-// src/blueprints/design/blueprint.ts
-var BLUEPRINT_KEY2 = "dxos.org/blueprint/design";
-var functions2 = Object.values(MarkdownFunctions);
+// src/blueprints/linear/blueprint.ts
+var BLUEPRINT_KEY2 = "org.dxos.blueprint.linear";
 var instructions2 = trim2`
-  You manage a design spec based on the conversation.
-  The design spec is a markdown document that is used to record the tasks.
-  The design spec document follows a hierarchical structure, with nested markdown bulleted sections.
-  Use the appropriate tools to read and write the design spec document.
-  Maintain the document so that it can convey all relevant points from the conversation.
-  When replying to the user, be terse with your comments about design doc handling.
-  Do not announce when you read or write the design spec document.
+  You are able to sync Linear workspaces.
+  Sometimes sync does not complete in one go and you need to call the function again.
+
+  Known workspaces:
+
+  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
 `;
 var make2 = () => Blueprint2.make({
   key: BLUEPRINT_KEY2,
-  name: "Design Spec",
-  description: "Preserve the conversation in the design spec.",
+  name: "Linear",
+  description: "Syncs Linear workspaces.",
   instructions: {
-    source: Ref5.make(Text2.make(instructions2))
+    source: Ref2.make(Text2.make({
+      content: instructions2
+    }))
   },
-  tools: functions2.map((fn22) => ToolId.make(fn22.key))
+  tools: Blueprint2.toolDefinitions({
+    operations: [
+      SyncIssues
+    ]
+  })
 });
 var blueprint2 = {
   key: BLUEPRINT_KEY2,
-  functions: functions2,
   make: make2
 };
-var blueprint_default2 = blueprint2;
+var blueprint_default3 = blueprint2;
 
-// src/blueprints/discord/blueprint.ts
-import { ToolId as ToolId2 } from "@dxos/ai";
-import { Blueprint as Blueprint3 } from "@dxos/blueprints";
-import { Ref as Ref6 } from "@dxos/echo";
-import { Text as Text3 } from "@dxos/schema";
-import { trim as trim3 } from "@dxos/util";
+// src/blueprints/planning/blueprint.ts
+import { Blueprint as Blueprint3 } from "@dxos/compute";
 
-// src/blueprints/discord/functions/fetch-messages.ts
-import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
-import { DiscordConfig, DiscordREST, DiscordRESTMemoryLive } from "dfx";
-import * as Array2 from "effect/Array";
-import * as Effect4 from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema4 from "effect/Schema";
-import { Obj as Obj2 } from "@dxos/echo";
-import { CredentialsService, TracingService, defineFunction as defineFunction4 } from "@dxos/functions";
-import { log } from "@dxos/log";
-import { Message } from "@dxos/types";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/discord/functions/fetch-messages.ts";
-var TimeRange = class extends Schema4.String.pipe(Schema4.pattern(/\d+(s|m|h|d)/)).annotations({
-  description: "Time range. 1d - 1 day, 2h - 2 hours, 30m - 30 minutes, 15s - 15 seconds.",
-  examples: [
-    "1d",
-    "2h",
-    "30m",
-    "15s"
-  ]
-}) {
-  static toSeconds(timeRange) {
-    const match = timeRange.match(/(\d+)(s|m|h|d)/);
-    if (!match) {
-      throw new Error(`Invalid time range: ${timeRange}`);
-    }
-    const [_, amount, unit] = match;
-    switch (unit) {
-      case "s":
-        return Number(amount);
-      case "m":
-        return Number(amount) * 60;
-      case "h":
-        return Number(amount) * 60 * 60;
-      case "d":
-        return Number(amount) * 24 * 60 * 60;
-      default:
-        throw new Error(`Invalid time range unit: ${unit}`);
-    }
-  }
-};
-var DiscordConfigFromCredential = Layer.unwrapEffect(Effect4.gen(function* () {
-  return DiscordConfig.layer({
-    token: yield* CredentialsService.getApiKey({
-      service: "discord.com"
-    }),
-    rest: {
-      baseUrl: "https://api-proxy.dxos.workers.dev/discord.com/api/v10"
-    }
-  });
-}));
-var DEFAULT_AFTER = 1704067200;
-var DEFAULT_LIMIT = 500;
-var DEFAULT_IGNORE_USERNAMES = [
-  "GitHub",
-  "Needle"
-];
-var fetch_messages_default = defineFunction4({
-  key: "dxos.org/function/fetch-discord-messages",
-  name: "Sync Discord messages",
-  inputSchema: Schema4.Struct({
-    serverId: Schema4.String.annotations({
-      description: "The ID of the server to fetch messages from."
-    }),
-    channelId: Schema4.optional(Schema4.String).annotations({
-      description: "The ID of the channel to fetch messages from. Will crawl all channels from the server if not specified."
-    }),
-    after: Schema4.optional(Schema4.Number).annotations({
-      description: "Fetch messages that were sent after a given date. Unix timestamp in seconds. Exclusive with `last`."
-    }),
-    last: TimeRange.annotations({
-      description: 'Time range to fetch most recent messages. Specifies the range in the past, from now. "1d" would fetch messages from the last 24 hours.'
-    }),
-    limit: Schema4.optional(Schema4.Number).annotations({
-      description: "The maximum number of messages to fetch."
-    }),
-    pageSize: Schema4.optional(Schema4.Number).annotations({
-      description: "The number of messages to fetch per page."
-    }),
-    ignoreUsernames: Schema4.optional(Schema4.Array(Schema4.String)).annotations({
-      description: "Exclude messages from these usernames."
-    })
-  }),
-  handler: Effect4.fnUntraced(function* ({ data: { serverId, channelId, after, last: last2, pageSize = 100, limit = DEFAULT_LIMIT, ignoreUsernames = DEFAULT_IGNORE_USERNAMES } }) {
-    if (!after && !last2) {
-      throw new Error("cannot specify both `after` and `last`");
-    }
-    const afterTs = last2 ? Date.now() / 1e3 - TimeRange.toSeconds(last2) : after ?? DEFAULT_AFTER;
-    const rest = yield* DiscordREST;
-    let channels = [];
-    channels.push(...yield* rest.listGuildChannels(serverId));
-    const { threads: guildThreads } = yield* rest.getActiveGuildThreads(serverId);
-    channels.push(...guildThreads);
-    if (channelId) {
-      channels = channels.filter((channel) => channel.id === channelId);
-    }
-    if (channels.length === 0) {
-      throw new Error("no channels found");
-    }
-    for (const channel of channels) {
-      log.info("channel", {
-        id: channel.id,
-        name: "name" in channel ? channel.name : void 0
-      }, {
-        F: __dxlog_file,
-        L: 136,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-    yield* TracingService.emitStatus({
-      message: `Will fetch from channels: ${channels.length}`
-    });
-    const threads = yield* Effect4.forEach(channels, Effect4.fnUntraced(function* (channel) {
-      const allMessages = [];
-      let lastMessage = Option.none();
-      while (true) {
-        const { id: lastId = void 0 } = Function.pipe(lastMessage, Option.map(Obj2.getKeys("discord.com")), Option.flatMap(Option.fromIterable), Option.getOrElse(() => ({
-          id: void 0
-        })));
-        const options = {
-          after: !lastId ? `${generateSnowflake(afterTs)}` : lastId,
-          limit: pageSize
-        };
-        log.info("fetching messages", {
-          lastId,
-          afterTs,
-          afterSnowflake: options.after,
-          after: parseSnowflake(options.after),
-          limit: options.limit
-        }, {
-          F: __dxlog_file,
-          L: 159,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const messages = yield* rest.listMessages(channel.id, options).pipe(Effect4.map(Array2.map(makeMessage)), Effect4.map(Array2.reverse), Effect4.catchTag("ErrorResponse", (err) => err.cause.code === 50001 ? Effect4.succeed([]) : Effect4.fail(err)));
-        if (messages.length > 0) {
-          lastMessage = Option.fromNullable(messages.at(-1));
-          allMessages.push(...messages);
-        } else {
-          break;
-        }
-        yield* TracingService.emitStatus({
-          message: `Fetched messages: ${allMessages.length}`
-        });
-        if (allMessages.length >= limit) {
-          break;
-        }
-      }
-      return {
-        discordChannelId: channel.id,
-        name: "name" in channel ? channel.name ?? void 0 : void 0,
-        messages: allMessages.filter((message) => !message.sender.name || !ignoreUsernames.includes(message.sender.name)).filter((message) => message.blocks.some((block) => block._tag === "text" && block.text.trim().length > 0))
-      };
-    }), {
-      concurrency: 10
-    });
-    return threads.filter((thread) => thread.messages.length > 0).map(serializeThread).join("\n");
-  }, Effect4.provide(DiscordRESTMemoryLive.pipe(Layer.provideMerge(DiscordConfigFromCredential)).pipe(Layer.provide(FetchHttpClient.layer))), Effect4.orDie)
+// src/blueprints/planning/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet3 } from "@dxos/compute";
+var PlanningHandlers = OperationHandlerSet3.lazy(() => import("./update-tasks-H7SWIFQL.mjs"));
+
+// src/blueprints/planning/blueprint.ts
+var BLUEPRINT_KEY3 = "org.dxos.blueprint.planning";
+var make3 = () => Blueprint3.make({
+  key: BLUEPRINT_KEY3,
+  name: "Planning",
+  description: "Plans and tracks complex tasks with artifact management.",
+  tools: Blueprint3.toolDefinitions({
+    operations: [
+      UpdateTasks
+    ]
+  })
 });
-var generateSnowflake = (unixTimestamp) => {
-  const discordEpoch = 1420070400000n;
-  return BigInt(unixTimestamp * 1e3) - discordEpoch << 22n;
-};
-var parseSnowflake = (snowflake) => {
-  const discordEpoch = 1420070400000n;
-  return new Date(Number((BigInt(snowflake) >> 22n) + discordEpoch));
+var blueprint3 = {
+  key: BLUEPRINT_KEY3,
+  make: make3
 };
-var makeMessage = (message) => Obj2.make(Message.Message, {
-  [Obj2.Meta]: {
-    keys: [
-      {
-        id: message.id,
-        source: "discord.com"
-      },
-      {
-        id: message.channel_id,
-        source: "discord.com/thread"
-      }
-    ]
+var blueprint_default4 = blueprint3;
+
+// src/blueprints/websearch/blueprint.ts
+import { Blueprint as Blueprint4 } from "@dxos/compute";
+import { Ref as Ref3 } from "@dxos/echo";
+import { Text as Text3 } from "@dxos/schema";
+
+// src/blueprints/websearch/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet4 } from "@dxos/compute";
+var WebSearchHandlers = OperationHandlerSet4.lazy(() => import("./fetch-KHMHV7JR.mjs"));
+
+// src/blueprints/websearch/blueprint.ts
+var BLUEPRINT_KEY4 = "org.dxos.blueprint.web-search";
+var make4 = () => Blueprint4.make({
+  key: BLUEPRINT_KEY4,
+  name: "Web Search",
+  description: "Search the web.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref3.make(Text3.make())
   },
-  sender: {
-    name: message.author.username
+  tools: Blueprint4.toolDefinitions({
+    operations: [
+      Fetch
+    ],
+    tools: [
+      "AnthropicWebSearch"
+    ]
+  })
+});
+var blueprint4 = {
+  key: BLUEPRINT_KEY4,
+  make: make4
+};
+var blueprint_default5 = blueprint4;
+
+// src/blueprints/websearch/toolkit.ts
+import * as AnthropicTool from "@effect/ai-anthropic/AnthropicTool";
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Layer from "effect/Layer";
+import { OpaqueToolkit } from "@dxos/ai";
+var WebSearchToolkit = Toolkit.make(AnthropicTool.WebSearch_20250305({}));
+var WebSearchToolkitOpaque = OpaqueToolkit.make(WebSearchToolkit, Layer.empty);
+
+// src/blueprints/browser/blueprint.ts
+import { Blueprint as Blueprint5 } from "@dxos/compute";
+import { Ref as Ref4 } from "@dxos/echo";
+import { Text as Text4 } from "@dxos/schema";
+import { trim as trim3 } from "@dxos/util";
+var BLUEPRINT_KEY5 = "org.dxos.blueprint.browser";
+var instructions3 = trim3`
+  You are able to connect and use a virtual browser with persistent session.
+  Browser tools are provided via MCP.
+`;
+var make6 = () => Blueprint5.make({
+  key: BLUEPRINT_KEY5,
+  name: "Browser",
+  description: "Access to a real isolated browser.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref4.make(Text4.make({
+      content: instructions3
+    }))
   },
-  created: message.timestamp,
-  blocks: [
+  mcpServers: [
     {
-      _tag: "text",
-      text: message.content
+      // https://dash.cloudflare.com/950816f3f59b079880a1ae33fb0ec320/workers/services/view/playwright-mcp-example/production
+      url: "https://playwright-mcp-example.dxos.workers.dev/sse",
+      protocol: "sse"
     }
   ]
 });
-var serializeThread = (thread) => {
-  return `<thread id=${thread.discordChannelId} name=${thread.name ?? ""}>
-${thread.messages.map((message) => `  ${message.sender.name}: ${message.blocks.filter((block) => block._tag === "text").map((block) => block.text).join(" ")}`).join("\n")}
-</thread>`;
-};
-
-// src/blueprints/discord/functions/index.ts
-var DiscordFunctions = {
-  Fetch: fetch_messages_default
+var blueprint5 = {
+  key: BLUEPRINT_KEY5,
+  make: make6
 };
+var blueprint_default6 = blueprint5;
 
-// src/blueprints/discord/blueprint.ts
-var BLUEPRINT_KEY3 = "dxos.org/blueprint/discord";
-var functions3 = Object.values(DiscordFunctions);
-var instructions3 = trim3`
-  You are able to fetch messages from Discord servers.
+// src/blueprints/database/blueprint.ts
+import { Blueprint as Blueprint6 } from "@dxos/compute";
+import { Ref as Ref5 } from "@dxos/echo";
+import { Text as Text5 } from "@dxos/schema";
+import { trim as trim4 } from "@dxos/util";
 
-  Known servers:
+// src/blueprints/database/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet5 } from "@dxos/compute";
+var DatabaseHandlers = OperationHandlerSet5.lazy(() => import("./context-add-VB7AOY3G.mjs"), () => import("./context-remove-VCM3VPSO.mjs"), () => import("./load-ALP3TK2E.mjs"), () => import("./object-create-Z57Y3X6Y.mjs"), () => import("./object-delete-X53LS37B.mjs"), () => import("./object-update-GVKSBR7T.mjs"), () => import("./query-PPJU5622.mjs"), () => import("./relation-create-XJ2IX6X3.mjs"), () => import("./relation-delete-EP4KXAFL.mjs"), () => import("./schema-add-Z5CY6P24.mjs"), () => import("./schema-list-W326VPVX.mjs"), () => import("./tag-add-VNIIOVJA.mjs"), () => import("./tag-remove-6R2R27W3.mjs"));
 
-  DXOS serverId: 837138313172353095
+// src/blueprints/database/blueprint.ts
+var BLUEPRINT_KEY6 = "org.dxos.blueprint.database";
+var instructions4 = trim4`
+  You can query, create, update, and delete objects in ECHO.
+  You can manage schemas, relations, tags, and add objects to the chat context.
 `;
-var make3 = () => Blueprint3.make({
-  key: BLUEPRINT_KEY3,
-  name: "Discord",
-  description: "Discord integration.",
+var make7 = () => Blueprint6.make({
+  key: BLUEPRINT_KEY6,
+  name: "Database",
+  description: "Query and manipulate objects in the ECHO database.",
+  agentCanEnable: true,
   instructions: {
-    source: Ref6.make(Text3.make(instructions3))
+    source: Ref5.make(Text5.make({
+      content: instructions4
+    }))
   },
-  tools: [
-    ToolId2.make(DiscordFunctions.Fetch.key)
-  ]
+  tools: Blueprint6.toolDefinitions({
+    operations: [
+      ContextAdd,
+      ContextRemove,
+      Load,
+      ObjectCreate,
+      ObjectDelete,
+      ObjectUpdate,
+      Query,
+      RelationCreate,
+      RelationDelete,
+      SchemaAdd,
+      SchemaList,
+      TagAdd,
+      TagRemove
+    ]
+  })
 });
-var blueprint3 = {
-  key: BLUEPRINT_KEY3,
-  functions: functions3,
-  make: make3
+var blueprint6 = {
+  key: BLUEPRINT_KEY6,
+  make: make7
 };
-var blueprint_default3 = blueprint3;
+var blueprint_default7 = blueprint6;
 
-// src/blueprints/project/blueprint.ts
-import { Blueprint as Blueprint4, Template } from "@dxos/blueprints";
+// src/blueprints/memory/blueprint.ts
+import { Blueprint as Blueprint7 } from "@dxos/compute";
+import { Ref as Ref6 } from "@dxos/echo";
+import { Text as Text6 } from "@dxos/schema";
 import { trim as trim5 } from "@dxos/util";
 
-// src/blueprints/project/functions/add-artifact.ts
-import * as Effect6 from "effect/Effect";
-import * as Schema8 from "effect/Schema";
-import { AiContextService as AiContextService2 } from "@dxos/assistant";
-import { Database as Database5, Obj as Obj6, Ref as Ref10 } from "@dxos/echo";
-import { defineFunction as defineFunction5 } from "@dxos/functions";
+// src/blueprints/memory/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet6 } from "@dxos/compute";
+var MemoryHandlers = OperationHandlerSet6.lazy(() => import("./save-GWAPLT3Z.mjs"), () => import("./query-U56GNEV6.mjs"), () => import("./delete-J3PMWP7Z.mjs"));
 
-// src/types/Chat.ts
-var Chat_exports = {};
-__export(Chat_exports, {
-  Chat: () => Chat,
-  CompanionTo: () => CompanionTo,
-  make: () => make4
-});
-import * as Schema5 from "effect/Schema";
-import { Annotation, Obj as Obj3, Ref as Ref7, Type } from "@dxos/echo";
-import { FormInputAnnotation, LabelAnnotation } from "@dxos/echo/internal";
-import { Queue } from "@dxos/echo-db";
-var Chat = Schema5.Struct({
-  name: Schema5.String.pipe(Schema5.optional),
-  queue: Ref7.Ref(Queue).pipe(FormInputAnnotation.set(false)),
-  // TODO(dmaretskyi): Eventually this and the message queue will be the same.
-  traceQueue: Ref7.Ref(Queue).pipe(FormInputAnnotation.set(false), Schema5.optional)
-}).pipe(Type.object({
-  typename: "dxos.org/type/assistant/Chat",
-  version: "0.2.0"
-}), LabelAnnotation.set([
-  "name"
-]), Annotation.IconAnnotation.set({
-  icon: "ph--atom--regular",
-  hue: "blue"
-}));
-var make4 = (props) => Obj3.make(Chat, props);
-var CompanionTo = Schema5.Struct({
-  id: Obj3.ID
-}).pipe(Type.relation({
-  typename: "dxos.org/relation/assistant/CompanionTo",
-  version: "0.1.0",
-  source: Chat,
-  target: Obj3.Unknown
-}));
+// src/blueprints/memory/blueprint.ts
+var BLUEPRINT_KEY7 = "org.dxos.blueprint.memory";
+var instructions5 = trim5`
+  You have the ability to save and recall memories.
+  Memories are persistent knowledge units stored in the database.
+  Use memories to remember facts, user preferences, decisions, and any knowledge that should persist across conversations.
 
-// src/types/Project.ts
-var Project_exports = {};
-__export(Project_exports, {
-  Project: () => Project,
-  getFromChatContext: () => getFromChatContext,
-  makeInitialized: () => makeInitialized,
-  resetChatHistory: () => resetChatHistory
+  When the user asks you to remember something, save it as a memory with a descriptive title.
+  When the user asks about something you might have stored, query your memories first.
+  You can also delete outdated or incorrect memories.
+`;
+var make8 = () => Blueprint7.make({
+  key: BLUEPRINT_KEY7,
+  name: "Memory",
+  description: "Persistent memory storage and retrieval.",
+  agentCanEnable: true,
+  instructions: {
+    source: Ref6.make(Text6.make({
+      content: instructions5
+    }))
+  },
+  tools: Blueprint7.toolDefinitions({
+    operations: [
+      SaveMemory,
+      QueryMemories,
+      DeleteMemory
+    ]
+  })
 });
-import * as Effect5 from "effect/Effect";
-import * as Function2 from "effect/Function";
-import * as Schema7 from "effect/Schema";
-import { AiContextBinder, AiContextService } from "@dxos/assistant";
-import { Annotation as Annotation2, Type as Type3 } from "@dxos/echo";
-import { Database as Database4, Obj as Obj5, Ref as Ref9, Relation } from "@dxos/echo";
-import { FormInputAnnotation as FormInputAnnotation2 } from "@dxos/echo/internal";
-import { Queue as Queue2 } from "@dxos/echo-db";
-import { acquireReleaseResource } from "@dxos/effect";
-import { QueueService } from "@dxos/functions";
-import { invariant } from "@dxos/invariant";
-import { QueueAnnotation, Text as Text4 } from "@dxos/schema";
+var blueprint7 = {
+  key: BLUEPRINT_KEY7,
+  make: make8
+};
+var blueprint_default8 = blueprint7;
 
-// src/types/Plan.ts
-var Plan_exports = {};
-__export(Plan_exports, {
-  Plan: () => Plan,
-  Task: () => Task,
-  TaskId: () => TaskId,
-  addTasks: () => addTasks,
-  formatPlan: () => formatPlan,
-  generateTaskId: () => generateTaskId,
-  makePlan: () => makePlan
-});
-import * as Schema6 from "effect/Schema";
-import { Obj as Obj4, Ref as Ref8, Type as Type2 } from "@dxos/echo";
-var TaskId = Schema6.String.pipe(Schema6.brand("@dxos/assistant-toolkit/TaskId"));
-var Task = Schema6.Struct({
-  /**
-  * Short task ID unique within the plan.
-  */
-  id: TaskId,
-  title: Schema6.String.annotations({
-    description: "Task title and description."
-  }),
-  status: Schema6.Literal("todo", "in-progress", "done"),
-  /**
-  * Parent task ID.
-  */
-  parent: Schema6.optional(TaskId).annotations({
-    description: "Parent task ID."
-  }),
-  /**
-  * Chat object that this task is associated with.
-  */
-  chat: Schema6.optional(Ref8.Ref(Chat))
-});
-var Plan = Schema6.Struct({
-  tasks: Schema6.Array(Task)
-}).pipe(Type2.object({
-  typename: "dxos.org/type/Plan",
-  version: "0.1.0"
-}));
-var generateTaskId = (plan) => {
-  const existingIds = plan.tasks.map((task) => {
-    const [num, letter] = task.id.split("-");
-    return parseInt(num);
-  }).filter((_) => !isNaN(_));
-  let newId;
-  if (existingIds.length === 0) {
-    newId = 1;
-  } else {
-    newId = Math.max(...existingIds) + 1;
+// src/blueprints/automation/blueprint.ts
+import { Blueprint as Blueprint8, Trigger, Operation } from "@dxos/compute";
+import { Ref as Ref7 } from "@dxos/echo";
+import { Text as Text7 } from "@dxos/schema";
+import { trim as trim6 } from "@dxos/util";
+var BLUEPRINT_KEY8 = "dxos.org/blueprint/automation";
+var instructions6 = trim6`
+  Automation allows you to automatically initiate actions based on events.
+  Automations are configured by creating a trigger that references a function.
+  Whenever event that matches the trigger occurs, the function is invoked.
+
+  ## Configuration
+
+  Triggers are configured by the properties of the Trigger object.
+  - enabled: Must be true for trigger to run.
+  - spec: Events that the trigger matches.
+  - function: Ref to a ${Operation.PersistentOperation.typename} object that will be invoked. Query the functions present in the space first, and reference them in the trigger.
+  - input: The spec of the input data that will be passed to the function.
+
+  ## Input patterns
+
+  Input to the invoked function is defined by the input property of the Trigger object.
+  It's an object that supports constants or template strings.
+
+  Example:
+
+  {
+    item: '{{event.item}}',
+    instructions: 'Summarize and perform entity-extraction'
+    mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
   }
-  return TaskId.make(`${newId}-${crypto.randomUUID().slice(0, 2)}`);
-};
-var addTasks = (plan, tasks) => {
-  for (const task of tasks) {
-    const taskId = generateTaskId(plan);
-    plan.tasks.push({
-      id: taskId,
-      ...task,
-      status: task.status ?? "todo"
-    });
+
+  ## Trigger kinds
+
+  - Timer: Triggered by a cron schedule.
+  - Queue: Subscribes and processes items begginging to end.
+            Note: queues are the same as feeds. The queue DXN should be of form: dxn:queue:data:<space-id>:<queue-id>.
+  - Subscription: Subscribes and processes database items based on a query.
+
+  Avoid: email and webhook triggers.
+
+  ## Editing triggers
+
+  Triggers are represented as objects of type ${Trigger.Trigger.typename}.
+  You need access to the Database blueprint to manipulate triggers.
+  Read trigger schema before manipulating triggers.
+  Having a Trigger object in the database is enough to setup an automation. 
+
+  ## Examples
+
+  Timer:
+
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "timer",
+      "cron": "*/5 * * * *"
+    }
   }
-  return plan;
-};
-var makePlan = (props) => {
-  const plan = Obj4.make(Plan, {
-    tasks: []
-  });
-  Obj4.change(plan, (plan2) => {
-    addTasks(plan2, props.tasks);
-  });
-  return plan;
-};
-var formatPlan = (plan) => {
-  return plan.tasks.map((task) => `- **${task.status?.toLocaleUpperCase()}**: ${task.title ?? "No title"} <!-- id=${task.id} -->`).join("\n");
-};
 
-// src/types/Project.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/types/Project.ts";
-var Project = Schema7.Struct({
-  name: Schema7.String,
-  spec: Ref9.Ref(Text4.Text).pipe(FormInputAnnotation2.set(false)),
-  plan: Ref9.Ref(Plan).pipe(FormInputAnnotation2.set(false)),
-  artifacts: Schema7.Array(Schema7.Struct({
-    // TODO(dmaretskyi): Consider gettings names from the artifact itself using Obj.getLabel.
-    name: Schema7.String,
-    data: Ref9.Ref(Obj5.Unknown)
-  })).pipe(FormInputAnnotation2.set(false)),
-  /**
-  * Incoming queue that the agent processes.
-  */
-  // NOTE: Named `queue` to conform to subscribable schema (see QueueAnnotation).
-  queue: Schema7.optional(Ref9.Ref(Queue2).pipe(FormInputAnnotation2.set(false))),
-  // TODO(dmaretskyi): Multiple chats.
-  chat: Schema7.optional(Ref9.Ref(Chat).pipe(FormInputAnnotation2.set(false))),
-  /**
-  * References to objects with a canonical queue property.
-  * Schema must have the QueueAnnotation.
-  */
-  // TODO(dmaretskyi): Turn into an array of objects when form-data
-  subscriptions: Schema7.Array(Ref9.Ref(Obj5.Unknown)).pipe(FormInputAnnotation2.set(false)),
-  useQualifyingAgent: Schema7.optional(Schema7.Boolean).annotations({
-    title: "Use qualifying agent on subscriptions",
-    description: "If enabled, the qualifying agent will be used to determine if the event is relevant to the project. Related events will be added to the input queue of the project. It is recommended to enable this."
-  })
-}).pipe(Type3.object({
-  typename: "dxos.org/type/Project",
-  version: "0.1.0"
-}), Annotation2.IconAnnotation.set({
-  icon: "ph--circuitry--regular",
-  hue: "green"
-}), QueueAnnotation.set(true));
-var makeInitialized = (props, blueprint11) => Effect5.gen(function* () {
-  const project = Obj5.make(Project, {
-    ...props,
-    spec: Ref9.make(Text4.make(props.spec)),
-    plan: Ref9.make(makePlan({
-      tasks: []
-    })),
-    artifacts: props.artifacts ?? [],
-    subscriptions: props.subscriptions ?? [],
-    useQualifyingAgent: props.useQualifyingAgent ?? true
-  });
-  yield* Database4.add(project);
-  const queue = yield* QueueService.createQueue();
-  const contextBinder = new AiContextBinder({
-    queue
-  });
-  const projectBlueprint = yield* Database4.add(Obj5.clone(blueprint11, {
-    deep: true
-  }));
-  yield* Effect5.promise(() => contextBinder.bind({
-    blueprints: [
-      Ref9.make(projectBlueprint),
-      ...props.blueprints ?? []
-    ],
-    objects: [
-      Ref9.make(project),
-      ...props.contextObjects ?? []
-    ]
-  }));
-  const chat = yield* Database4.add(make4({
-    [Obj5.Parent]: project,
-    queue: Ref9.fromDXN(queue.dxn)
-  }));
-  yield* Database4.add(Relation.make(CompanionTo, {
-    [Relation.Source]: chat,
-    [Relation.Target]: project
-  }));
-  const inputQueue = yield* QueueService.createQueue();
-  Obj5.change(project, (project2) => {
-    project2.chat = Ref9.make(chat);
-    project2.queue = Ref9.fromDXN(inputQueue.dxn);
-  });
-  return project;
-});
-var resetChatHistory = (project) => Effect5.gen(function* () {
-  invariant(project.chat, "Project must have an existing chat to reset.", {
-    F: __dxlog_file2,
-    L: 148,
-    S: this,
-    A: [
-      "project.chat",
-      "'Project must have an existing chat to reset.'"
-    ]
-  });
-  const existingQueue = yield* project.chat.pipe(Database4.load).pipe(Effect5.map((_) => _.queue), Effect5.flatMap(Database4.load));
-  const existingContextBinder = yield* acquireReleaseResource(() => new AiContextBinder({
-    queue: existingQueue
-  }));
-  const blueprints = existingContextBinder.getBlueprints().map((blueprint11) => Ref9.make(blueprint11));
-  const objects = existingContextBinder.getObjects().map((object) => Ref9.make(object));
-  const queue = yield* QueueService.createQueue();
-  const contextBinder = new AiContextBinder({
-    queue
-  });
-  yield* Effect5.promise(() => contextBinder.bind({
-    blueprints,
-    objects
-  }));
-  const chat = yield* Database4.add(make4({
-    queue: Ref9.fromDXN(queue.dxn)
-  }));
-  Obj5.change(project, (project2) => {
-    project2.chat = Ref9.make(chat);
-  });
-  yield* Database4.add(Relation.make(CompanionTo, {
-    [Relation.Source]: chat,
-    [Relation.Target]: project
-  }));
-}).pipe(Effect5.scoped);
-var getFromChatContext = Effect5.gen(function* () {
-  const projects = yield* Function2.pipe(AiContextService.findObjects(Project));
-  if (projects.length !== 1) {
-    throw new Error("There should be exactly one project in context. Got: " + projects.length);
-  }
-  const project = projects[0];
-  return project;
-});
+  Queue:
 
-// src/blueprints/project/functions/add-artifact.ts
-var add_artifact_default = defineFunction5({
-  key: "dxos.org/function/project/add-artifact",
-  name: "Add artifact",
-  description: "Adds a new artifact.",
-  inputSchema: Schema8.Struct({
-    name: Schema8.String.annotations({
-      description: "The name of the artifact to add."
-    }),
-    artifact: Ref10.Ref(Obj6.Unknown).annotations({
-      description: "The artifact to add. Do NOT guess or try to generate the ID."
-    })
-  }),
-  services: [
-    AiContextService2
-  ],
-  handler: Effect6.fnUntraced(function* ({ data }) {
-    if (!(yield* Database5.load(data.artifact))) {
-      throw new Error("Artifact not found.");
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "queue",
+      "queue": "dxn:queue:data:XXX:YYY"
     }
-    const project = yield* Project_exports.getFromChatContext;
-    Obj6.change(project, (project2) => {
-      project2.artifacts.push({
-        name: data.name,
-        data: data.artifact
-      });
-    });
-  }, AiContextService2.fixFunctionHandlerType)
-});
+  }
 
-// src/blueprints/project/functions/agent.ts
-import * as Effect7 from "effect/Effect";
-import * as Schema9 from "effect/Schema";
-import { AiService } from "@dxos/ai";
-import { AiContextService as AiContextService3, AiConversation } from "@dxos/assistant";
-import { Database as Database6, Obj as Obj7, Ref as Ref11 } from "@dxos/echo";
-import { acquireReleaseResource as acquireReleaseResource2 } from "@dxos/effect";
-import { TriggerEvent, defineFunction as defineFunction6 } from "@dxos/functions";
-import { invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/project/functions/agent.ts";
-var agent_default = defineFunction6({
-  key: "dxos.org/function/project/agent",
-  name: "Project Agent",
-  description: "Agentic worker that drives the project autonomously.",
-  inputSchema: Schema9.Struct({
-    project: Schema9.suspend(() => Ref11.Ref(Project_exports.Project)),
-    prompt: Schema9.optional(Schema9.String),
-    event: Schema9.optional(TriggerEvent.TriggerEvent)
-  }),
-  outputSchema: Schema9.Void,
-  services: [
-    AiContextService3
-  ],
-  handler: Effect7.fnUntraced(function* ({ data }) {
-    const project = yield* Database6.load(data.project);
-    invariant2(Obj7.instanceOf(Project_exports.Project, project), void 0, {
-      F: __dxlog_file3,
-      L: 33,
-      S: this,
-      A: [
-        "Obj.instanceOf(Project.Project, project)",
-        ""
-      ]
-    });
-    invariant2(project.chat, "Project has no chat.", {
-      F: __dxlog_file3,
-      L: 34,
-      S: this,
-      A: [
-        "project.chat",
-        "'Project has no chat.'"
-      ]
-    });
-    const chatQueue = yield* project.chat.pipe(Database6.load, Effect7.flatMap((chat) => Database6.load(chat.queue)));
-    invariant2(chatQueue, "Project chat queue not found.", {
-      F: __dxlog_file3,
-      L: 40,
-      S: this,
-      A: [
-        "chatQueue",
-        "'Project chat queue not found.'"
-      ]
-    });
-    const conversation = yield* acquireReleaseResource2(() => new AiConversation({
-      queue: chatQueue
-    }));
-    const iniativesInContext = conversation.context.getObjects().filter(Obj7.instanceOf(Project_exports.Project));
-    if (iniativesInContext.length !== 1) {
-      throw new Error("There should be exactly one project in context. Got: " + iniativesInContext.length);
-    }
-    if (!data.prompt && !data.event) {
-      throw new Error("Either prompt or event must be provided.");
-    }
-    let input = "";
-    if (data.prompt) {
-      input += `${data.prompt}
+  Subscription:
 
-`;
+  {
+    "function": { "/": "dxn:echo:AAA:ZZZ" },
+    "enabled": true,
+    "spec": {
+      "kind": "subscription",
+      "query": { "ast": { "type": "select", "filter": { "type": "object", "typename": "dxn:type:org.dxos.type.person" } } }
     }
-    if (data.event) {
-      input += `<event>
-${JSON.stringify(data.event, null, 2)}
-</event>
-
+  }
 `;
-    }
-    yield* conversation.createRequest({
-      prompt: input
-    }).pipe(Effect7.retry({
-      times: 2
-    }));
-  }, Effect7.scoped, Effect7.provide(AiService.model("@anthropic/claude-sonnet-4-5")), AiContextService3.fixFunctionHandlerType)
-});
-
-// src/blueprints/project/functions/get-context.ts
-import * as Effect8 from "effect/Effect";
-import * as Schema10 from "effect/Schema";
-import { AiContextService as AiContextService4 } from "@dxos/assistant";
-import { Database as Database7, Obj as Obj8 } from "@dxos/echo";
-import { defineFunction as defineFunction7 } from "@dxos/functions";
-var get_context_default = defineFunction7({
-  key: "dxos.org/function/project/get-context",
-  name: "Get Project Context",
-  description: "Get the context of an project.",
-  inputSchema: Schema10.Struct({}),
-  outputSchema: Schema10.Struct({
-    id: Schema10.String,
-    name: Schema10.String,
-    spec: Schema10.String,
-    plan: Schema10.String,
-    artifacts: Schema10.Array(Schema10.Struct({
-      name: Schema10.String,
-      type: Schema10.optional(Schema10.String),
-      dxn: Schema10.optional(Schema10.String)
+var make9 = () => Blueprint8.make({
+  key: BLUEPRINT_KEY8,
+  name: "Triggers",
+  description: "Trigger management and automation.",
+  instructions: {
+    source: Ref7.make(Text7.make({
+      content: instructions6
     }))
-  }),
-  services: [
-    AiContextService4
-  ],
-  handler: Effect8.fnUntraced(function* ({ data: _data }) {
-    const project = yield* Project_exports.getFromChatContext;
-    return {
-      id: project.id,
-      name: project.name,
-      spec: yield* project.spec.pipe(Database7.load).pipe(Effect8.map((_) => _.content), Effect8.catchTag("ObjectNotFoundError", () => Effect8.succeed("No spec found."))),
-      plan: yield* project.plan?.pipe(Database7.load).pipe(Effect8.map(Plan_exports.formatPlan), Effect8.catchTag("ObjectNotFoundError", () => Effect8.succeed("No plan found."))) ?? Effect8.succeed("No plan found."),
-      artifacts: yield* Effect8.forEach(project.artifacts, (artifact) => Effect8.gen(function* () {
-        return {
-          name: artifact.name,
-          type: yield* Database7.load(artifact.data).pipe(Effect8.map(Obj8.getTypename), Effect8.catchTag("ObjectNotFoundError", () => Effect8.succeed("Artifact not found."))),
-          dxn: artifact.data.dxn.toString()
-        };
-      }))
-    };
-  }, AiContextService4.fixFunctionHandlerType)
-});
-
-// src/blueprints/project/functions/qualifier.ts
-import * as LanguageModel from "@effect/ai/LanguageModel";
-import * as Prompt from "@effect/ai/Prompt";
-import * as Effect9 from "effect/Effect";
-import * as Schema11 from "effect/Schema";
-import { AiService as AiService2 } from "@dxos/ai";
-import { Database as Database8, Obj as Obj9, Ref as Ref12 } from "@dxos/echo";
-import { TriggerEvent as TriggerEvent2, defineFunction as defineFunction8 } from "@dxos/functions";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { trim as trim4 } from "@dxos/util";
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/project/functions/qualifier.ts";
-var qualifier_default = defineFunction8({
-  key: "dxos.org/function/project/qualifier",
-  name: "Project Qualifier",
-  description: "Qualifier that determines if the event is relevant to the project. Puts the data into the input queue of the project.",
-  inputSchema: Schema11.Struct({
-    project: Schema11.suspend(() => Ref12.Ref(Project_exports.Project)),
-    event: TriggerEvent2.TriggerEvent
-  }),
-  outputSchema: Schema11.Void,
-  services: [],
-  handler: Effect9.fnUntraced(function* ({ data }) {
-    const project = yield* Database8.load(data.project);
-    invariant3(Obj9.instanceOf(Project_exports.Project, project), void 0, {
-      F: __dxlog_file4,
-      L: 32,
-      S: this,
-      A: [
-        "Obj.instanceOf(Project.Project, project)",
-        ""
-      ]
-    });
-    invariant3(project.chat, "Project has no chat.", {
-      F: __dxlog_file4,
-      L: 33,
-      S: this,
-      A: [
-        "project.chat",
-        "'Project has no chat.'"
-      ]
-    });
-    const { id, name, queue } = project;
-    if (!queue) {
-      throw new Error("Project has no queue.");
-    }
-    const plan = yield* Database8.load(project.plan);
-    const spec = yield* Database8.load(project.spec);
-    const { value: { isRelevant } } = yield* LanguageModel.generateObject({
-      schema: Schema11.Struct({
-        isRelevant: Schema11.Boolean
-      }),
-      prompt: Prompt.fromMessages([
-        Prompt.systemMessage({
-          content: trim4`
-              You are a qualifying agent that determines if the event is relevant to the project.
-              Respond with true if the event is relevant to the project, false otherwise.
-              If you are not sure, return true.
-              The qualified events will be forwarded to the larger agent that will process them.
-              <project id="${id}" name="${name}">
-                <spec>
-                ${spec.content}
-                </spec>
-                <plan>
-                  ${Plan_exports.formatPlan(plan)}
-                </plan>
-              </project>
-            `
-        }),
-        Prompt.userMessage({
-          content: [
-            Prompt.makePart("text", {
-              text: trim4`
-                  <event>
-                    ${JSON.stringify(data.event, null, 2)}
-                  </event>
-                `
-            })
-          ]
-        })
-      ])
-    });
-    if (isRelevant) {
-      const queueTarget = yield* Database8.load(queue);
-      if ("queue" in data.event && data.event.item) {
-        const obj = data.event.item;
-        yield* Effect9.promise(() => queueTarget.append([
-          obj
-        ]));
-      } else if ("subject" in data.event && Ref12.isRef(data.event.subject)) {
-        const obj = yield* Database8.load(data.event.subject);
-        yield* Effect9.promise(() => queueTarget.append([
-          obj
-        ]));
-      } else {
-        throw new Error("Invalid event.");
-      }
-    }
-  }, Effect9.scoped, Effect9.provide(AiService2.model("@anthropic/claude-sonnet-4-5")))
+  }
 });
-
-// src/blueprints/project/functions/index.ts
-var ProjectFunctions = {
-  AddArtifact: add_artifact_default,
-  Agent: agent_default,
-  GetContext: get_context_default,
-  Qualifier: qualifier_default
+var blueprint8 = {
+  key: BLUEPRINT_KEY8,
+  make: make9
 };
+var blueprint_default9 = blueprint8;
 
-// src/blueprints/project/blueprint.ts
-var BLUEPRINT_KEY4 = "dxos.org/blueprint/project";
-var functions4 = [
-  ProjectFunctions.AddArtifact
-];
-var make5 = () => Blueprint4.make({
-  key: BLUEPRINT_KEY4,
-  name: "Project blueprint",
-  instructions: Template.make({
-    source: trim5`
-        You work on an project. Each project has a spec - the goal of the project.
-        The project plan shows the current progress of the project.
-        Project has an number of associated artifacts you can read/write.
-        Spec and plan are also artifacts.
-        You can edit them if necessary.
-
-        IMPORTANT: When create a new artifact, always add it to the project using the add-artifact function.
+// src/blueprints/blueprint-manager/blueprint.ts
+import { Blueprint as Blueprint9, Template } from "@dxos/compute";
+import { trim as trim7 } from "@dxos/util";
 
-        {{#with project}}
-        <project id="{{id}}" name="{{name}}">
-          <spec>
-            {{spec}}
-          </spec>
-          <plan>
-            {{plan}}
-          </plan>
+// src/blueprints/blueprint-manager/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet7 } from "@dxos/compute";
+var BlueprintManagerHandlers = OperationHandlerSet7.lazy(() => import("./query-blueprints-KXADGHSA.mjs"), () => import("./enable-blueprints-LBDZH2CY.mjs"), () => import("./update-blueprints-N2AK2VUR.mjs"));
 
-          <artifacts>
-          {{#each artifacts}}
-            <artifact type="{{type}}" dxn="{{dxn}}">
-              {{name}}
-            </artifact>
-          {{/each}}
-          </artifacts>
-        </project>
-        {{/with}}
+// src/blueprints/blueprint-manager/blueprint.ts
+var BLUEPRINT_KEY9 = "org.dxos.blueprint.blueprint-manager";
+var make10 = () => Blueprint9.make({
+  key: BLUEPRINT_KEY9,
+  name: "Blueprint Manager",
+  description: "Query and enable blueprints in the current conversation.",
+  instructions: Template.make({
+    source: trim7`
+        You can query available blueprints and enable them in the current conversation.
+        Use [query-blueprints] to refresh the list of available blueprints.
+        Use [refresh-blueprints] to update blueprint objects stored in the database from the built-in registry when they have drifted.
+        Use [enable-blueprints] to enable blueprints by their keys. Always call [query-blueprints] first.
+        Only blueprints with agentCanEnable=true can be enabled by the agent.
+
+        <available_blueprints>
+        {{#each blueprints}}
+        - {{key}} "{{name}}"{{#if description}} -- {{description}}{{/if}}{{#if agentCanEnable}} [agent-can-enable]{{/if}}
+        {{/each}}
+        </available_blueprints>
+
+        NOTE: You must enable the blueprint to use it, only then the tools from that blueprint will appear.
       `,
     inputs: [
       {
-        name: "project",
-        kind: "function",
-        function: "dxos.org/function/project/get-context"
+        name: "blueprints",
+        kind: "operation",
+        operation: QueryBlueprints.meta.key
       }
     ]
   }),
-  tools: Blueprint4.toolDefinitions({
-    functions: functions4
-  })
-});
-var blueprint4 = {
-  key: BLUEPRINT_KEY4,
-  functions: functions4,
-  make: make5
-};
-var blueprint_default4 = blueprint4;
-
-// src/blueprints/linear/blueprint.ts
-import { ToolId as ToolId3 } from "@dxos/ai";
-import { Blueprint as Blueprint5 } from "@dxos/blueprints";
-import { Ref as Ref15 } from "@dxos/echo";
-import { Text as Text5 } from "@dxos/schema";
-import { trim as trim6 } from "@dxos/util";
-
-// src/blueprints/linear/functions/sync-issues.ts
-import * as FetchHttpClient2 from "@effect/platform/FetchHttpClient";
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as Array7 from "effect/Array";
-import * as Effect11 from "effect/Effect";
-import * as Function3 from "effect/Function";
-import * as Schema12 from "effect/Schema";
-import { Filter as Filter2, Obj as Obj11, Query as Query2, Ref as Ref14 } from "@dxos/echo";
-import { Database as Database10 } from "@dxos/echo";
-import { CredentialsService as CredentialsService2, defineFunction as defineFunction9, withAuthorization } from "@dxos/functions";
-import { log as log3 } from "@dxos/log";
-import { Person, Pipeline, Task as Task2 } from "@dxos/types";
-
-// src/sync/sync.ts
-import * as Effect10 from "effect/Effect";
-import { Filter, Obj as Obj10, Query, Ref as Ref13 } from "@dxos/echo";
-import { Database as Database9 } from "@dxos/echo";
-import { failedInvariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/sync/sync.ts";
-var syncObjects = Effect10.fn("syncObjects")(function* (objs, { foreignKeyId }) {
-  return yield* Effect10.forEach(objs, Effect10.fnUntraced(function* (obj) {
-    for (const key of Object.keys(obj)) {
-      if (typeof key !== "string" || key === "id") continue;
-      if (!Ref13.isRef(obj[key])) continue;
-      const ref = obj[key];
-      if (!ref.target) continue;
-      if (Obj10.getDXN(ref.target).isLocalObjectId()) {
-        const [target] = yield* syncObjects([
-          ref.target
-        ], {
-          foreignKeyId
-        });
-        obj[key] = Ref13.make(target);
-      }
-    }
-    const schema = Obj10.getSchema(obj) ?? failedInvariant("No schema.");
-    const foreignId = Obj10.getKeys(obj, foreignKeyId)[0]?.id ?? failedInvariant("No foreign key.");
-    const [existing] = yield* Database9.runQuery(Query.select(Filter.foreignKeys(schema, [
-      {
-        source: foreignKeyId,
-        id: foreignId
-      }
-    ])));
-    log2("sync object", {
-      type: Obj10.getTypename(obj),
-      foreignId,
-      existing: existing ? Obj10.getDXN(existing) : void 0
-    }, {
-      F: __dxlog_file5,
-      L: 48,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!existing) {
-      yield* Database9.add(obj);
-      return obj;
-    } else {
-      copyObjectData(existing, obj);
-      return existing;
-    }
-  }), {
-    concurrency: 1
-  });
-});
-var copyObjectData = (existing, newObj) => {
-  Obj10.change(existing, (obj) => {
-    for (const key of Object.keys(newObj)) {
-      if (typeof key !== "string" || key === "id") continue;
-      if (typeof newObj[key] !== "string" && typeof newObj[key] !== "number" && typeof newObj[key] !== "boolean" && !Ref13.isRef(newObj[key])) continue;
-      obj[key] = newObj[key];
-    }
-    for (const key of Object.keys(obj)) {
-      if (typeof key !== "string" || key === "id") continue;
-      if (!(key in newObj)) {
-        delete obj[key];
-      }
-    }
-    for (const foreignKey of Obj10.getMeta(newObj).keys) {
-      Obj10.deleteKeys(obj, foreignKey.source);
-      Obj10.getMeta(obj).keys.push({
-        ...foreignKey
-      });
-    }
-  });
-};
-
-// src/util/graphql.ts
-import * as HttpBody from "@effect/platform/HttpBody";
-var graphqlRequestBody = (query2, variables = {}) => HttpBody.json({
-  query: query2,
-  variables
-});
-
-// src/blueprints/linear/functions/sync-issues.ts
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/linear/functions/sync-issues.ts";
-var queryIssues = `
-query Issues($teamId: String!, $after: DateTimeOrDuration!) {
-  team(id: $teamId) {
-    id
-    name
-
-
-   issues(last: 150, orderBy: updatedAt, filter: {
-    updatedAt: { gt: $after }
-   }) {
-    edges {
-        node {
-            id
-            title
-            createdAt
-            updatedAt
-            description
-            assignee { id, name }
-            state {
-                name
-            }
-            project {
-                id
-                name
-            }
-        }
-        cursor
-    }
-    pageInfo {
-        hasNextPage
-        endCursor
-    }
-    }
-  }
-}
-`;
-var LINEAR_ID_KEY = "linear.app/id";
-var LINEAR_TEAM_ID_KEY = "linear.app/teamId";
-var LINEAR_UPDATED_AT_KEY = "linear.app/updatedAt";
-var sync_issues_default = defineFunction9({
-  key: "dxos.org/function/linear/sync-issues",
-  name: "Linear",
-  description: "Sync issues from Linear.",
-  inputSchema: Schema12.Struct({
-    team: Schema12.String.annotations({
-      description: "Linear team id."
-    })
-  }),
-  handler: Effect11.fnUntraced(function* ({ data }) {
-    const credential = yield* CredentialsService2.getCredential({
-      service: "linear.app"
-    });
-    const client = yield* HttpClient.HttpClient.pipe(Effect11.map(withAuthorization(credential.apiKey)));
-    const after = yield* getLatestUpdateTimestamp(data.team, Task2.Task);
-    log3.info("will fetch", {
-      after
-    }, {
-      F: __dxlog_file6,
-      L: 93,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const response = yield* client.post("https://api.linear.app/graphql", {
-      body: yield* graphqlRequestBody(queryIssues, {
-        teamId: data.team,
-        after
-      })
-    });
-    const json2 = yield* response.json;
-    const tasks = json2.data.team.issues.edges.map((edge) => mapLinearIssue(edge.node, {
-      teamId: data.team
-    }));
-    log3.info("Fetched tasks", {
-      count: tasks.length
-    }, {
-      F: __dxlog_file6,
-      L: 106,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      objects: yield* syncObjects(tasks, {
-        foreignKeyId: LINEAR_ID_KEY
-      }),
-      syncComplete: tasks.length < 150
-    };
-  }, Effect11.provide(FetchHttpClient2.layer))
-});
-var getLatestUpdateTimestamp = Effect11.fnUntraced(function* (teamId, dataType) {
-  const existingTasks = yield* Database10.runQuery(Query2.type(dataType).select(Filter2.foreignKeys(dataType, [
-    {
-      source: LINEAR_TEAM_ID_KEY,
-      id: teamId
-    }
-  ])));
-  return Function3.pipe(existingTasks, Array7.map((task) => Obj11.getKeys(task, LINEAR_UPDATED_AT_KEY).at(0)?.id), Array7.filter((x) => x !== void 0), Array7.reduce("2025-01-01T00:00:00.000Z", (acc, x) => x > acc ? x : acc));
-});
-var mapLinearPerson = (person, { teamId }) => Obj11.make(Person.Person, {
-  [Obj11.Meta]: {
-    keys: [
-      {
-        id: person.id,
-        source: LINEAR_ID_KEY
-      },
-      {
-        id: teamId,
-        source: LINEAR_TEAM_ID_KEY
-      }
-    ]
-  },
-  nickname: person.name
-});
-var mapLinearIssue = (issue, { teamId }) => Obj11.make(Task2.Task, {
-  [Obj11.Meta]: {
-    keys: [
-      {
-        id: issue.id,
-        source: LINEAR_ID_KEY
-      },
-      {
-        id: issue.updatedAt,
-        source: LINEAR_UPDATED_AT_KEY
-      },
-      {
-        id: teamId,
-        source: LINEAR_TEAM_ID_KEY
-      }
+  tools: Blueprint9.toolDefinitions({
+    operations: [
+      QueryBlueprints,
+      EnableBlueprints,
+      UpdateBlueprints
     ]
-  },
-  title: issue.title ?? void 0,
-  description: issue.description ?? void 0,
-  assigned: !issue.assignee ? void 0 : Ref14.make(mapLinearPerson(issue.assignee, {
-    teamId
-  })),
-  // TODO(dmaretskyi): Sync those (+ linear team as org?).
-  // state: issue.state.name,
-  project: !issue.project ? void 0 : Ref14.make(Pipeline.make({
-    [Obj11.Meta]: {
-      keys: [
-        {
-          id: issue.project.id,
-          source: LINEAR_ID_KEY
-        },
-        {
-          id: teamId,
-          source: LINEAR_TEAM_ID_KEY
-        }
-      ]
-    },
-    name: issue.project.name
-  }))
-});
-
-// src/blueprints/linear/functions/index.ts
-var LinearFunctions = {
-  Sync: sync_issues_default
-};
-
-// src/blueprints/linear/blueprint.ts
-var BLUEPRINT_KEY5 = "dxos.org/blueprint/linear";
-var functions5 = Object.values(LinearFunctions);
-var instructions4 = trim6`
-  You are able to sync Linear workspaces.
-  Sometimes sync does not complete in one go and you need to call the function again.
-
-  Known workspaces:
-
-  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
-`;
-var make6 = () => Blueprint5.make({
-  key: BLUEPRINT_KEY5,
-  name: "Linear",
-  description: "Syncs Linear workspaces.",
-  instructions: {
-    source: Ref15.make(Text5.make(instructions4))
-  },
-  tools: functions5.map((tool) => ToolId3.make(tool.key))
+  })
 });
-var blueprint5 = {
-  key: BLUEPRINT_KEY5,
-  functions: functions5,
-  make: make6
+var blueprint9 = {
+  key: BLUEPRINT_KEY9,
+  make: make10
 };
-var blueprint_default5 = blueprint5;
-
-// src/blueprints/planning/blueprint.ts
-import { Blueprint as Blueprint6 } from "@dxos/blueprints";
-
-// src/blueprints/planning/functions/update-tasks.ts
-import * as Effect12 from "effect/Effect";
-import * as Schema13 from "effect/Schema";
-import { AiContextService as AiContextService5 } from "@dxos/assistant";
-import { Database as Database11, Obj as Obj12 } from "@dxos/echo";
-import { defineFunction as defineFunction10 } from "@dxos/functions";
-import { trim as trim7 } from "@dxos/util";
-var INSTRUCTIONS = trim7`
-TASK MANAGEMENT TOOL - USAGE GUIDELINES
-
-This tool maintains an organized task list during work sessions to track progress, break down objectives, and ensure thoroughness. After creating initial tasks, update them silently without announcing changes to the user.
-
-=== CORE USAGE PRINCIPLES ===
-
-Create and manage tasks for: multi-step objectives requiring 3+ distinct actions, complex projects needing careful sequencing, user requests for task organization, multiple deliverables provided together, new instructions (capture as tasks immediately with new IDs), completed work (mark done and add follow-ups), and active work (mark as 'in-progress', limit one at a time).
-
-Skip task management for: single straightforward actions, simple requests achievable in 1-2 steps, informational queries, quick lookups or clarifications, and avoid creating verification tasks unless requested.
-
-=== TOOL SPECIFICATION ===
-
-update-tasks requires an array of task objects. Each task object contains:
-- id (string, required): unique identifier like "task_1" or "research_sources"
-- title (string, optional): update to clarify or refine task description
-- status (string, optional): 'todo' | 'in-progress' | 'done'
-
-Task status meanings: 'todo' means not yet started, 'in-progress' means currently being worked on, 'done' means completed successfully.
+var blueprint_default10 = blueprint9;
 
-=== OPERATIONAL GUIDELINES ===
-
-Update tasks in real-time as work progresses. Mark tasks 'done' immediately upon completion. Maintain only ONE task with 'in-progress' status at a time. Complete current tasks before starting new ones. Use specific, actionable task titles. Break complex work into manageable logical pieces. Batch task updates with other actions when possible for efficiency.
-
-=== USAGE EXAMPLES ===
-
-<example type="research_project">
-<user_message>I need to research sustainable packaging options and write a report comparing costs and environmental impact.</user_message>
-<assistant_action>
-Creates tasks:
-1. {id: "research_materials", title: "Research sustainable packaging materials", status: "in-progress"}
-2. {id: "compare_costs", title: "Compile cost comparison data", status: "todo"}
-3. {id: "assess_impact", title: "Evaluate environmental impact metrics", status: "todo"}
-4. {id: "draft_report", title: "Write comparative analysis report", status: "todo"}
-
-Begins research work immediately in same response.
-</assistant_action>
-<reasoning>Multi-phase project requiring systematic tracking across research, analysis, and writing stages.</reasoning>
-</example>
-
-<example type="event_planning">
-<user_message>Help me plan a team retreat - venue, agenda, catering, and send invitations.</user_message>
-<assistant_action>
-Creates tasks:
-1. {id: "venue_options", title: "Research and recommend venues", status: "in-progress"}
-2. {id: "draft_agenda", title: "Create retreat agenda", status: "todo"}
-3. {id: "arrange_catering", title: "Coordinate catering options", status: "todo"}
-4. {id: "send_invites", title: "Draft and send invitations", status: "todo"}
-</assistant_action>
-<reasoning>Multiple distinct deliverables with dependencies requiring organized tracking.</reasoning>
-</example>
-
-<example type="document_analysis">
-<user_message>Review this 30-page contract for key terms, risks, and negotiation points.</user_message>
-<assistant_action>
-Creates tasks:
-1. {id: "extract_key_terms", title: "Identify key contractual terms", status: "in-progress"}
-2. {id: "flag_risks", title: "Flag potential risks and liabilities", status: "todo"}
-3. {id: "negotiation_points", title: "Compile negotiation recommendations", status: "todo"}
-4. {id: "summary_doc", title: "Prepare executive summary", status: "todo"}
-</assistant_action>
-<reasoning>Substantial analysis work requiring methodical breakdown and systematic review.</reasoning>
-</example>
-
-<example type="multiple_deliverables">
-<user_message>I need: 1) competitor analysis for three companies, 2) SWOT analysis, 3) market positioning recommendations.</user_message>
-<assistant_action>
-Creates tasks:
-1. {id: "competitor_research", title: "Research three competitor companies", status: "in-progress"}
-2. {id: "swot_analysis", title: "Develop SWOT analysis", status: "todo"}
-3. {id: "positioning_recs", title: "Create market positioning recommendations", status: "todo"}
-</assistant_action>
-<reasoning>User provided numbered list of distinct deliverables requiring separate effort.</reasoning>
-</example>
-
-<example type="skip_simple_question">
-<user_message>What's the difference between renewable and sustainable energy?</user_message>
-<assistant_action>Provides explanation directly without creating tasks.</assistant_action>
-<reasoning>Informational request with no actionable work to complete or track.</reasoning>
-</example>
-
-<example type="skip_quick_lookup">
-<user_message>Find the population of Tokyo.</user_message>
-<assistant_action>Searches and provides answer without task tracking.</assistant_action>
-<reasoning>Single straightforward lookup completable immediately.</reasoning>
-</example>
-
-<example type="skip_trivial_task">
-<user_message>Summarize this 2-paragraph email.</user_message>
-<assistant_action>Provides summary directly without creating tasks.</assistant_action>
-<reasoning>Single simple action requiring no breakdown or progress tracking.</reasoning>
-</example>
-
-<example type="skip_single_action">
-<user_message>Check if my flight is on time.</user_message>
-<assistant_action>Performs lookup and reports status without task management.</assistant_action>
-<reasoning>One-step action with immediate completion, no organizational benefit from tasks.</reasoning>
-</example>
-
-=== BEST PRACTICES ===
+// src/blueprints/project-wizard/blueprint.ts
+import { Blueprint as Blueprint10, Template as Template2 } from "@dxos/compute";
+import { trim as trim8 } from "@dxos/util";
 
-For task creation: use descriptive unique IDs reflecting the work, start first task as 'in-progress', batch initial creation with beginning work. For progress tracking: update status immediately upon completion, keep only one 'in-progress' task unless parallel work is natural, add follow-up tasks as they emerge. For task breakdown: aim for reasonably-scoped tasks, group related small actions into logical units, split tasks requiring different approaches.
+// src/blueprints/project-wizard/functions/index.ts
+import { OperationHandlerSet as OperationHandlerSet8 } from "@dxos/compute";
+var AgentWizardHandlers = OperationHandlerSet8.lazy(() => import("./create-project-EIF4OJMY.mjs"), () => import("./project-rules-IVDHKSKI.mjs"), () => import("./sync-triggers-CDMJVW6E.mjs"));
 
-When uncertain whether to use task management, err on the side of creating tasks. Proactive organization demonstrates thoroughness and ensures comprehensive work completion.
-`;
-var TaskProps = Schema13.Struct({
-  id: Plan_exports.TaskId,
-  title: Schema13.String,
-  status: Schema13.Literal("todo", "in-progress", "done")
-});
-var update_tasks_default = defineFunction10({
-  key: "dxos.org/function/planning/update-tasks",
-  name: "Update tasks",
-  description: INSTRUCTIONS,
-  inputSchema: Schema13.Struct({
-    tasks: Schema13.Array(TaskProps)
+// src/blueprints/project-wizard/blueprint.ts
+var BLUEPRINT_KEY10 = "org.dxos.blueprint.agent-wizard";
+var make11 = () => Blueprint10.make({
+  key: BLUEPRINT_KEY10,
+  name: "Agent Wizard",
+  description: "Help the user create a new agent (subscriptions, optional cron timer, sync-triggers after edits).",
+  agentCanEnable: true,
+  instructions: Template2.make({
+    source: trim8`
+        You are a wizard that helps the user create a new agent.
+
+        Agents are goal oriented and autonomously driven.
+        Each agent has instructions - the goal of the agent.
+        The instructions also typically describe what actions to perform in reaction to events (emails).
+        The agent has a number of associated artifacts to work with.
+        Agents can subscribe to emails.
+
+        Agents have a \`cron\` field: when set, the agent runs on a timer on that schedule (standard cron syntax).
+        Use \`cron\` when the user wants the agent to run periodically (e.g. "every morning", "once a day", "every 5 minutes").
+        Examples: \`0 9 * * *\` for daily at 09:00, or \`*/5 * * * *\` for every 5 minutes.
+        Timer triggers bypass the qualifier and invoke the agent worker directly on the schedule.
+
+        The agent itself is an ECHO object and can be edited like any other object using the database blueprint.
+        You can edit the agent's instructions, name, and other properties directly.
+        If you edit the agent's \`enabled\` field, \`filterEvents\` field, subscriptions array, or \`cron\` field, you MUST call the sync-triggers function afterward to synchronize the triggers (\`enabled\` is applied to all triggers).
+
+        IMPORTANT: Before attempting to create an agent call the [agent-rules] tool to get the rules for creating an agent.
+      `
   }),
-  handler: Effect12.fn(function* ({ data: { tasks: newTasks } }) {
-    const project = yield* Project_exports.getFromChatContext;
-    const plan = yield* Database11.load(project.plan);
-    Obj12.change(plan, (plan2) => {
-      for (const task of newTasks) {
-        const existingTask = plan2.tasks.find((t) => t.id === task.id);
-        if (existingTask) {
-          existingTask.title = task.title;
-          existingTask.status = task.status;
-        } else {
-          plan2.tasks.push({
-            id: task.id,
-            title: task.title,
-            status: task.status
-          });
-        }
-      }
-    });
-    return trim7`
-      Tasks updated. Don't forget to mark tasks as done when you're done with them or update their status to 'in-progress' when you start working on them.
-      Current plan:
-      <plan>
-        ${Plan_exports.formatPlan(plan)}
-      </plan>
-    `;
-  }, AiContextService5.fixFunctionHandlerType)
-});
-
-// src/blueprints/planning/functions/index.ts
-var PlanningFunctions = {
-  UpdateTasks: update_tasks_default
-};
-
-// src/blueprints/planning/blueprint.ts
-var BLUEPRINT_KEY6 = "dxos.org/blueprint/planning";
-var functions6 = Object.values(PlanningFunctions);
-var make7 = () => Blueprint6.make({
-  key: BLUEPRINT_KEY6,
-  name: "Planning",
-  description: "Plans and tracks complex tasks with artifact management.",
-  tools: Blueprint6.toolDefinitions({
-    functions: [
-      PlanningFunctions.UpdateTasks
+  tools: Blueprint10.toolDefinitions({
+    operations: [
+      AgentRules,
+      CreateAgent,
+      SyncTriggers
     ]
   })
 });
-var blueprint6 = {
-  key: BLUEPRINT_KEY6,
-  functions: functions6,
-  make: make7
+var blueprint10 = {
+  key: BLUEPRINT_KEY10,
+  make: make11
 };
-var blueprint_default6 = blueprint6;
-
-// src/blueprints/research/blueprint.ts
-import { ToolId as ToolId4 } from "@dxos/ai";
-import { Blueprint as Blueprint7 } from "@dxos/blueprints";
-import { Ref as Ref18 } from "@dxos/echo";
-import { Text as Text7 } from "@dxos/schema";
-import { trim as trim11 } from "@dxos/util";
-
-// src/blueprints/research/functions/document-create.ts
-import * as Effect13 from "effect/Effect";
-import * as Schema14 from "effect/Schema";
-import { Database as Database12, Obj as Obj13, Ref as Ref16, Relation as Relation2 } from "@dxos/echo";
-import { TracingService as TracingService2, defineFunction as defineFunction11 } from "@dxos/functions";
-import { log as log4 } from "@dxos/log";
-import { Markdown as Markdown4 } from "@dxos/plugin-markdown/types";
-import { HasSubject } from "@dxos/types";
-import { trim as trim8 } from "@dxos/util";
-var __dxlog_file7 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/research/functions/document-create.ts";
-var document_create_default = defineFunction11({
-  key: "dxos.org/function/research/document-create",
-  name: "Create research document",
-  description: "Creates a note summarizing the research.",
-  inputSchema: Schema14.Struct({
-    subject: Ref16.Ref(Obj13.Unknown).annotations({
-      description: trim8`
-        ID of the object (organization, contact, etc.) for which the research was performed. 
-      `
-    }),
-    name: Schema14.String.annotations({
-      description: "Name of the document."
-    }),
-    content: Schema14.String.annotations({
-      description: trim8`
-        Content of the note. 
-        Supports (and are prefered) references to research objects using @ syntax and <object> tags (refer to research blueprint instructions).
-      `
-    })
-  }),
-  outputSchema: Schema14.Struct({
-    document: Schema14.String.annotations({
-      description: "DXN of the created document."
-    })
-  }),
-  handler: Effect13.fnUntraced(function* ({ data: { subject, name, content } }) {
-    log4.info("Creating research document", {
-      subject,
-      name,
-      content
-    }, {
-      F: __dxlog_file7,
-      L: 41,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    yield* Database12.flush({
-      indexes: true
-    });
-    yield* TracingService2.emitStatus({
-      message: "Creating research document..."
-    });
-    const target = yield* Database12.load(subject);
-    const object = yield* Database12.add(Markdown4.make({
-      name,
-      content
-    }));
-    yield* Database12.add(Relation2.make(HasSubject.HasSubject, {
-      [Relation2.Source]: object,
-      [Relation2.Target]: target,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
-    yield* Database12.flush({
-      indexes: true
-    });
-    log4.info("Created research document", {
-      subject,
-      object
-    }, {
-      F: __dxlog_file7,
-      L: 67,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return {
-      document: Obj13.getDXN(object).toString()
-    };
-  })
-});
-
-// src/blueprints/research/functions/research.ts
-import * as Toolkit2 from "@effect/ai/Toolkit";
-import * as AnthropicTool from "@effect/ai-anthropic/AnthropicTool";
-import * as Array10 from "effect/Array";
-import * as Effect16 from "effect/Effect";
-import * as Function5 from "effect/Function";
-import * as Layer3 from "effect/Layer";
-import * as Option3 from "effect/Option";
-import * as Schema17 from "effect/Schema";
-import * as String16 from "effect/String";
-import { AiService as AiService3, ConsolePrinter } from "@dxos/ai";
-import { GenericToolkit } from "@dxos/ai";
-import { AiSession, GenerationObserver, ToolExecutionServices, createToolkit } from "@dxos/assistant";
-import { Template as Template2 } from "@dxos/blueprints";
-import { Entity as Entity2, Obj as Obj16 } from "@dxos/echo";
-import { Database as Database15 } from "@dxos/echo";
-import { TracingService as TracingService3, defineFunction as defineFunction12 } from "@dxos/functions";
-import { Person as Person2 } from "@dxos/types";
-import { trim as trim10 } from "@dxos/util";
+var blueprint_default11 = blueprint10;
 
 // src/crud/graph.ts
 import * as Tool from "@effect/ai/Tool";
-import * as Toolkit from "@effect/ai/Toolkit";
+import * as Toolkit2 from "@effect/ai/Toolkit";
 import * as Context from "effect/Context";
-import * as Effect14 from "effect/Effect";
-import * as Function4 from "effect/Function";
-import * as Option2 from "effect/Option";
-import * as Schema15 from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
-import { Entity, Filter as Filter3, Obj as Obj14, Query as Query3, Type as Type4 } from "@dxos/echo";
-import { Database as Database13 } from "@dxos/echo";
-import { ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, createObject, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
+import { Entity, Filter, Obj, Query as Query2, Type } from "@dxos/echo";
+import { Database } from "@dxos/echo";
 import { isEncodedReference } from "@dxos/echo-protocol";
+import { ReferenceAnnotationId, RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId, createObject, getTypeAnnotation, getTypeIdentifierAnnotation } from "@dxos/echo/internal";
 import { mapAst } from "@dxos/effect";
 import { ContextQueueService } from "@dxos/functions";
 import { DXN, ObjectId } from "@dxos/keys";
-import { log as log5 } from "@dxos/log";
+import { log } from "@dxos/log";
 import { deepMapValues, isNonNullable, trim as trim9 } from "@dxos/util";
-var __dxlog_file8 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/crud/graph.ts";
-var Subgraph = Schema15.Struct({
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant-toolkit/src/crud/graph.ts";
+var Subgraph = Schema.Struct({
   /** Objects and relations. */
-  objects: Schema15.Array(Schema15.Any)
+  objects: Schema.Array(Schema.Any)
 });
 var findRelatedSchema = async (db, anchor) => {
   const allSchemas = await db.graph.schemaRegistry.query().run();
@@ -1603,34 +589,34 @@ var isSchemaAddressableByDxn = (schema, dxn) => {
   }
   const t = dxn.asTypeDXN();
   if (t) {
-    return t.type === Type4.getTypename(schema);
+    return t.type === Type.getTypename(schema);
   }
   return false;
 };
-var LocalSearchToolkit = Toolkit.make(Tool.make("search_local_search", {
+var LocalSearchToolkit = Toolkit2.make(Tool.make("search_local_search", {
   description: "Search the local database for information using a vector index",
   parameters: {
-    query: Schema15.String.annotations({
+    query: Schema.String.annotations({
       description: "The query to search for. Could be a question or a topic or a set of keywords."
     })
   },
-  success: Schema15.Unknown,
-  failure: Schema15.Never,
+  success: Schema.Unknown,
+  failure: Schema.Never,
   dependencies: [
-    Database13.Service
+    Database.Service
   ]
 }));
 var LocalSearchHandler = LocalSearchToolkit.toLayer({
-  search_local_search: Effect14.fn(function* ({ query: query2 }) {
-    const objects = yield* Database13.runQuery(Query3.select(Filter3.text(query2, {
+  search_local_search: Effect.fn(function* ({ query }) {
+    const objects = yield* Database.runQuery(Query2.select(Filter.text(query, {
       type: "vector"
     })));
     const results = [
       ...objects
     ];
-    const option = yield* Effect14.serviceOption(ContextQueueService);
-    if (Option2.isSome(option)) {
-      const queueObjects = yield* Effect14.promise(() => option.value.queue.queryObjects());
+    const option = yield* Effect.serviceOption(ContextQueueService);
+    if (Option.isSome(option)) {
+      const queueObjects = yield* Effect.promise(() => option.value.queue.queryObjects());
       results.push(...queueObjects);
     }
     return trim9`
@@ -1643,13 +629,13 @@ var LocalSearchHandler = LocalSearchToolkit.toLayer({
 var GraphWriterSchema = class extends Context.Tag("@dxos/assistant/GraphWriterSchema")() {
 };
 var makeGraphWriterToolkit = ({ schema }) => {
-  return Toolkit.make(Tool.make("graph_writer", {
+  return Toolkit2.make(Tool.make("graph_writer", {
     description: "Write to the local graph database",
     parameters: createExtractionSchema(schema).fields,
-    success: Schema15.Unknown,
-    failure: Schema15.Never,
+    success: Schema.Unknown,
+    failure: Schema.Never,
     dependencies: [
-      Database13.Service,
+      Database.Service,
       ContextQueueService
     ]
   }).annotateContext(Context.make(GraphWriterSchema, {
@@ -1659,29 +645,29 @@ var makeGraphWriterToolkit = ({ schema }) => {
 var makeGraphWriterHandler = (toolkit, { onAppend } = {}) => {
   const { schema } = Context.get(toolkit.tools.graph_writer.annotations, GraphWriterSchema);
   return toolkit.toLayer({
-    graph_writer: Effect14.fn(function* (input) {
-      const { db } = yield* Database13.Service;
+    graph_writer: Effect.fn(function* (input) {
+      const { db } = yield* Database.Service;
       const { queue } = yield* ContextQueueService;
-      const data = yield* Effect14.promise(() => sanitizeObjects(schema, input, db, queue));
-      yield* Effect14.promise(() => queue.append(data));
-      const dxns = data.map((obj) => Obj14.getDXN(obj));
+      const data = yield* Effect.promise(() => sanitizeObjects(schema, input, db, queue));
+      yield* Effect.promise(() => queue.append(data));
+      const dxns = data.map((obj) => Obj.getDXN(obj));
       onAppend?.(dxns);
       return dxns;
     })
   });
 };
 var createExtractionSchema = (types) => {
-  return Schema15.Struct({
+  return Schema.Struct({
     ...Object.fromEntries(types.map(preprocessSchema).map((schema, index) => [
       `objects_${getSanitizedSchemaName(types[index])}`,
-      Schema15.optional(Schema15.Array(schema)).annotations({
-        description: `The objects of type: ${Type4.getDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option2.getOrElse(() => ""))}`
+      Schema.optional(Schema.Array(schema)).annotations({
+        description: `The objects of type: ${Type.getDXN(types[index])?.asTypeDXN().type}. ${SchemaAST.getDescriptionAnnotation(types[index].ast).pipe(Option.getOrElse(() => ""))}`
       })
     ]))
   });
 };
 var getSanitizedSchemaName = (schema) => {
-  return Type4.getDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
+  return Type.getDXN(schema).asTypeDXN().type.replaceAll(/[^a-zA-Z0-9]+/g, "_");
 };
 var sanitizeObjects = async (types, data, db, queue) => {
   const entries = types.map((type) => data[`objects_${getSanitizedSchemaName(type)}`]?.map((object) => ({
@@ -1729,25 +715,15 @@ var sanitizeObjects = async (types, data, db, queue) => {
     if (Entity.getKind(entry.schema) === "relation") {
       const sourceDxn = resolveId(data2.source);
       if (!sourceDxn) {
-        log5.warn("source not found", {
+        log.warn("source not found", {
           source: data2.source
-        }, {
-          F: __dxlog_file8,
-          L: 273,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: void 0 });
       }
       const targetDxn = resolveId(data2.target);
       if (!targetDxn) {
-        log5.warn("target not found", {
+        log.warn("target not found", {
           target: data2.target
-        }, {
-          F: __dxlog_file8,
-          L: 277,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 199, S: void 0 });
       }
       delete data2.source;
       delete data2.target;
@@ -1759,7 +735,7 @@ var sanitizeObjects = async (types, data, db, queue) => {
       schema: entry.schema
     };
   }).filter((object) => !existingIds.has(object.data.id));
-  const dbObjects = await db.query(Query3.select(Filter3.id(...existingIds))).run();
+  const dbObjects = await db.query(Query2.select(Filter.id(...existingIds))).run();
   const queueObjects = await queue?.getObjectsById([
     ...existingIds
   ]) ?? [];
@@ -1767,16 +743,11 @@ var sanitizeObjects = async (types, data, db, queue) => {
     ...dbObjects,
     ...queueObjects
   ].filter(isNonNullable);
-  log5.info("objects", {
+  log.info("objects", {
     dbObjects,
     queueObjects,
     existingIds
-  }, {
-    F: __dxlog_file8,
-    L: 298,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 223, S: void 0 });
   const missing = Array.from(existingIds).filter((id) => !objects.some((object) => object.id === id));
   if (missing.length > 0) {
     throw new Error(`Object IDs do not point to existing objects: ${missing.join(", ")}`);
@@ -1813,8 +784,8 @@ var sanitizeObjects = async (types, data, db, queue) => {
     return [];
   });
 };
-var SoftRef = Schema15.Struct({
-  "/": Schema15.String
+var SoftRef = Schema.Struct({
+  "/": Schema.String
 }).annotations({
   description: "Reference to another object."
 });
@@ -1825,1797 +796,114 @@ var preprocessSchema = (schema) => {
       return ast;
     }
     visited.add(ast);
-    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option2.isSome)) {
+    if (SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome)) {
       return SoftRef.ast;
     }
     return mapAst(ast, (child) => go(child, visited));
   };
-  return Schema15.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema15.omit("id"), Schema15.extend(Schema15.Struct({
-    id: Schema15.String.annotations({
+  return Schema.make(mapAst(schema.ast, (ast) => go(ast))).pipe(Schema.omit("id"), Schema.extend(Schema.Struct({
+    id: Schema.String.annotations({
       description: "The id of this object. Come up with a unique id based on your judgement."
     })
-  })), isRelationSchema ? Schema15.extend(Schema15.Struct({
-    source: Schema15.String.annotations({
+  })), isRelationSchema ? Schema.extend(Schema.Struct({
+    source: Schema.String.annotations({
       description: "The id of the source object for this relation."
     }),
-    target: Schema15.String.annotations({
+    target: Schema.String.annotations({
       description: "The id of the target object for this relation."
     })
-  })) : Function4.identity);
+  })) : Function.identity);
 };
 
-// src/blueprints/research/types/index.ts
-import { Text as Text6 } from "@dxos/schema";
-import { Event, HasConnection, HasRelationship, LegacyOrganization, LegacyPerson, Pipeline as Pipeline2, Task as Task3 } from "@dxos/types";
+// src/functions/agent/index.ts
+import { OperationHandlerSet as OperationHandlerSet9 } from "@dxos/compute";
+var AgentHandlers = OperationHandlerSet9.lazy(() => import("./prompt-Y7NN7M5D.mjs"));
 
-// src/blueprints/research/types/ResearchGraph.ts
-var ResearchGraph_exports = {};
-__export(ResearchGraph_exports, {
-  ResearchGraph: () => ResearchGraph,
-  contextQueueLayer: () => contextQueueLayer,
-  create: () => create,
-  query: () => query
-});
-import * as Effect15 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
-import * as Schema16 from "effect/Schema";
-import { Database as Database14, Obj as Obj15, Query as Query4, Ref as Ref17, Type as Type5 } from "@dxos/echo";
-import { SystemTypeAnnotation } from "@dxos/echo/internal";
-import { Queue as Queue3 } from "@dxos/echo-db";
-import { ContextQueueService as ContextQueueService2, QueueService as QueueService2 } from "@dxos/functions";
-var ResearchGraph = Schema16.Struct({
-  queue: Ref17.Ref(Queue3)
-}).pipe(Type5.object({
-  typename: "dxos.org/type/ResearchGraph",
-  version: "0.1.0"
-}), SystemTypeAnnotation.set(true));
-var create = Effect15.fn("createResearchGraph")(function* () {
-  const queue = yield* QueueService2.createQueue();
-  return yield* Database14.add(Obj15.make(ResearchGraph, {
-    queue: Ref17.fromDXN(queue.dxn)
-  }));
-});
-var query = Effect15.fn("queryResearchGraph")(function* () {
-  const objects = yield* Database14.runQuery(Query4.type(ResearchGraph));
-  return objects.at(0);
+// src/toolkits/WebToolkit.ts
+var WebToolkit_exports = {};
+__export(WebToolkit_exports, {
+  WebToolkit: () => WebToolkit,
+  layer: () => layer
 });
-var contextQueueLayer = Layer2.unwrapEffect(Effect15.gen(function* () {
-  const researchGraph = (yield* query()) ?? (yield* create());
-  const researchQueue = yield* Database14.load(researchGraph.queue);
-  return ContextQueueService2.layer(researchQueue);
-}));
-
-// src/blueprints/research/types/index.ts
-var ResearchDataTypes = [
-  // Objects
-  Event.Event,
-  Task3.Task,
-  Text6.Text,
-  // TODO(wittjosiah): Until views (e.g., Table) support relations this needs to be expressed via organization ref.
-  // Employer.Employer,
-  // Organization.Organization,
-  LegacyPerson,
-  LegacyOrganization,
-  Pipeline2.Pipeline,
-  // Relations
-  HasRelationship.HasRelationship,
-  HasConnection.HasConnection
-];
-
-// raw-loader:/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/research/functions/research-instructions.tpl?raw
-var research_instructions_default = "You are the Research Agent.\n\nThe Research Agent is an expert assistant that conducts in-depth research using real-time web search.\nThe Research Agent outputs results in a structured format matching the schema provided.\n\nThe Research Agent is equipped with the ability to:\n\n- Generate precise and effective search queries \n- Request web pages by query.\n- Synthesize accurate, clear, and structured answers using reliable information from the retrieved content\n{{#if entityExtraction}}\n- Search the local database for information using a vector index (through a `local_search` tool)\n{{/if}}\n\nThe Research Agent always follows these principles:\n\n- Relevance First: The Research Agent only returns facts supported by content in retrieved web pages. The Research Agent never fabricates or guesses information.\n- Summarize, Don't Copy: The Research Agent synthesizes and rephrases content in its own words. The Research Agent quotes only when necessary.\n- Multiple Sources: The Research Agent cross-references at least 2 sources before drawing conclusions, unless the information is directly stated and non-controversial.\n- Transparency: The Research Agent mentions which sources were used and explains how it arrived at conclusions.\n- Accuracy Over Brevity: The Research Agent prefers detailed, technically accurate explanations over shallow summaries.\n- The Research Agent admits uncertainty rather than misleading.\n{{#if entityExtraction}}\n- The Research Agent picks the most concrete schema types for extracted information.\n- The Research Agent fills schema fields completely with information it is confident about, and omits fields it is not confident about.\n- When outputting results, the Research Agent adds extra data that fits the schema even if not directly related to the user's question.\n- The Research Agent creates relations and references between new objects found and what's already in the database.\n- The Research Agent does not create objects that are already in the database.\n- The Research Agent re-uses existing object IDs as references when enriching existing objects.\n- The Research Agent ALWAYS calls the `graph_writer` at the end to save the data. This conversation will be deleted, so only the data written to the graph will be preserved.\n{{/if}}\n\nThe Research Agent may be asked for:\n\n- Technical explanations\n- Literature reviews  \n- Comparisons\n- Emerging trends\n- Implementation strategies\n\nThe Research Agent begins by interpreting the user's request, then:\n\nThe Research Agent breaks it into sub-questions (if applicable).\n\nFor each sub-question, the Research Agent generates a clear, concise web search query.\n\nThe Research Agent extracts and synthesizes relevant answers.\n\nThe Research Agent's output includes:\n\n- A clear, structured answer to the user's question\n- A citation list or link list of sources used\n\nOptionally, the Research Agent provides follow-up suggestions or questions for deeper inquiry.\n\nHere's how the Research Agent operates:\n\n1. The Research Agent analyzes the user's request and identifies key topics to search for (3 or more), printing them out.\n2. The Research Agent performs a web search for each topic.\n3. The Research Agent reads and analyzes results, cross references information from multiple sources, and represents conflicting information as ranges of possible values.\n\n{{#if entityExtraction}}\n4. The Research Agent searches the local database for information using a vector index that might link to the user's question.\n6. The Research Agent creates relations and references between new objects and existing database objects when related, using existing object IDs as references.\n7. The Research Agent selects the most concrete schema types for extracted information, using multiple types as needed, and prints its decision and reasoning.\n5. The Research Agent creates a clear, structured answer to the user's question.\n8. The Research Agent submits results using the specific schema.\n{{/if}}\n\n{{#if entityExtraction}}\nIMPORTANT:\n- The Research Agent always runs the `local_search` tool to search the local database at least once before submitting results.\n- The Research Agent does not create objects that already exist in the database.\n- Ids that are not in the database are human-readable strings like `ivan_zhao_1`.\n{{/if}}\n\nStatus reporting:\n\nThe Research Agent reports its status frequently using the `<status>` tags: <status>Searching for Google Founders</status>\nThe Research Agent reports its status in-between each tool call and before submitting results.\n\n{{#if entityExtraction}}\n<example>\n\nBased on my research, I can now provide information about Google and it's founders.\n\nThe following objects are already in the database, I will not submit them again, but I'll re-use their IDs as references:\n\n- 01JWRDEHPB5TT2JQQQC15038BT Google\n- 01JWRDEHPA14CYW2NW9FAH6DJJ Larry Page\n- 01JWRDEHPBN0BBJP57B9S108W6 Sergey Brin\n\nI will use the following schema to construct new objects:\n\n- type:dxos.org/type/Organization for Alphabet Inc.\n- type:dxos.org/type/Person for Ivan Zhao\n- type:dxos.org/type/Person for Simon Last\n- dxn:type:dxos.org/relation/Employer for Ivan's employer\n- dxn:type:dxos.org/relation/Employer for Simon's employer\n\n<status>Formatting results</status>\n\n</example>\n{{/if}}\n\nLast content block is the full research note -- the result of the research.\n";
-
-// src/blueprints/research/functions/research.ts
-var research_default = defineFunction12({
-  key: "dxos.org/function/research",
-  name: "Research",
-  description: trim10`
-    Search the web to research information about the given subject.
-    Inserts structured data into the research graph. 
-    Creates a research summary and returns the objects created.
-  `,
-  inputSchema: Schema17.Struct({
-    query: Schema17.String.annotations({
-      description: trim10`
-        The search query.
-        If doing research on an object then load it first and pass it as JSON.
-      `
-    }),
-    instructions: Schema17.optional(Schema17.String).annotations({
-      description: trim10`
-        The instructions for the research agent. 
-      `
-    }),
-    // TOOD(burdon): Move to context.
-    mockSearch: Schema17.optional(Schema17.Boolean).annotations({
-      description: "Whether to use the mock search tool.",
-      default: false
-    }),
-    entityExtraction: Schema17.optional(Schema17.Boolean).annotations({
-      description: trim10`
-        Whether to extract structured entities from the research. 
-        Experimental feature only enable if user explicitly requests it.
-      `,
-      default: false
-    })
-  }),
-  outputSchema: Schema17.Struct({
-    document: Schema17.optional(Schema17.String).annotations({
-      description: "The generated research document."
-    }),
-    objects: Schema17.Array(Schema17.Unknown).annotations({
-      description: "Structured objects created during the research process."
-    })
-  }),
-  handler: Effect16.fnUntraced(function* ({ data: { query: query2, instructions: instructions8, mockSearch = false, entityExtraction = false } }) {
-    if (mockSearch) {
-      const mockPerson = yield* Database15.add(Obj16.make(Person2.Person, {
-        preferredName: "John Doe",
-        emails: [
-          {
-            value: "john.doe@example.com"
-          }
-        ],
-        phoneNumbers: [
-          {
-            value: "123-456-7890"
-          }
-        ]
-      }));
-      return {
-        document: trim10`
-            The research ran in test-mode and was mocked. Proceed as usual.
-            We reference John Doe to test reference: ${Obj16.getDXN(mockPerson)}
-          `,
-        objects: [
-          Obj16.toJSON(mockPerson)
-        ]
-      };
-    }
-    yield* Database15.flush({
-      indexes: true
-    });
-    yield* TracingService3.emitStatus({
-      message: "Starting research..."
-    });
-    const NativeWebSearch = Toolkit2.make(AnthropicTool.WebSearch_20250305({}));
-    let toolkit = NativeWebSearch;
-    let handlers = Layer3.empty;
-    const objectDXNs = [];
-    if (entityExtraction) {
-      const GraphWriterToolkit = makeGraphWriterToolkit({
-        schema: ResearchDataTypes
-      });
-      const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
-        onAppend: (dxns) => objectDXNs.push(...dxns)
-      });
-      toolkit = Toolkit2.merge(toolkit, LocalSearchToolkit, GraphWriterToolkit);
-      handlers = Layer3.mergeAll(handlers, LocalSearchHandler, GraphWriterHandler).pipe(Layer3.provide(ResearchGraph_exports.contextQueueLayer));
-    }
-    const finishedToolkit = yield* createToolkit({
-      toolkit
-    }).pipe(Effect16.provide(handlers));
-    const session = new AiSession();
-    const result = yield* session.run({
-      prompt: query2,
-      system: join(Template2.process(research_instructions_default, {
-        entityExtraction
-      }), instructions8 && `<instructions>${instructions8}</instructions>`),
-      toolkit: finishedToolkit,
-      observer: GenerationObserver.fromPrinter(new ConsolePrinter({
-        tag: "research"
-      }))
-    });
-    const objects = yield* Effect16.forEach(objectDXNs, (dxn) => Database15.resolve(dxn)).pipe(Effect16.map(Array10.map((obj) => Entity2.toJSON(obj))));
-    return {
-      document: extractLastTextBlock(result),
-      objects
-    };
-  }, Effect16.provide(AiService3.model("@anthropic/claude-sonnet-4-0").pipe(Layer3.merge(ToolExecutionServices), Layer3.provide(GenericToolkit.providerEmpty))))
-});
-var join = (...strings) => strings.filter(Boolean).join("\n\n");
-var extractLastTextBlock = (result) => {
-  return Function5.pipe(result, Array10.last, Option3.map(Function5.flow((_) => _.blocks, Array10.reverse, Array10.dropWhile((_) => _._tag === "stats"), Array10.takeWhile((_) => _._tag === "text"), Array10.reverse, Array10.map((_) => _.text), Array10.reduce("", String16.concat))), Option3.getOrElse(() => ""));
-};
-
-// src/blueprints/research/functions/index.ts
-var ResearchFunctions = {
-  Create: document_create_default,
-  Research: research_default
-};
-
-// src/blueprints/research/blueprint.ts
-var BLUEPRINT_KEY7 = "dxos.org/blueprint/research";
-var functions7 = Object.values(ResearchFunctions);
-var instructions5 = trim11`
-  {{! Research }}
-
-  You are an analyst that does research tasks using tools that scrape the web and create structured data.
-  Structured data extraction is an experimental feature -- only enable it if the user explicitly requests it in the prompt.
-  Prefer updating existing notes instead of creating new ones.
-
-  <structured_mode>
-    When you are done, reply with the created objects.
-    Do not print the data, instead reply with inline references to the created objects.
-    Those will be later substituted with the pills representing the created objects.
-    Print the rest of the created objects as block references after the main note.
-
-    <example>
-      Based on my research, Google was founded by @dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M and @dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW9H2ZQ
-
-      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn></object>
-      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW9H2ZQ</dxn></object>
-      <object><dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK46K31DDW62PBW92333</dxn></object>
-    </example>
-  </structured_mode>
-
-  <unstructured_mode>
-    Reply normally with the text mode of the result of your research.
-  </unstructured_mode>
-`;
-var make13 = () => Blueprint7.make({
-  key: BLUEPRINT_KEY7,
-  name: "Research",
-  description: "Researches the web and creates structured data.",
-  instructions: {
-    source: Ref18.make(Text7.make(instructions5))
-  },
-  tools: functions7.map((fn22) => ToolId4.make(fn22.key))
-});
-var blueprint7 = {
-  key: BLUEPRINT_KEY7,
-  functions: functions7,
-  make: make13
-};
-var blueprint_default7 = blueprint7;
-
-// src/blueprints/websearch/blueprint.ts
-import { ToolId as ToolId5 } from "@dxos/ai";
-import { Blueprint as Blueprint8 } from "@dxos/blueprints";
-import { Ref as Ref19 } from "@dxos/echo";
-import { Text as Text8 } from "@dxos/schema";
-var BLUEPRINT_KEY8 = "dxos.org/blueprint/web-search";
-var functions8 = [];
-var make14 = () => Blueprint8.make({
-  key: BLUEPRINT_KEY8,
-  name: "Web Search",
-  description: "Search the web.",
-  instructions: {
-    source: Ref19.make(Text8.make())
-  },
-  tools: [
-    ToolId5.make("AnthropicWebSearch")
-  ]
-});
-var blueprint8 = {
-  key: BLUEPRINT_KEY8,
-  functions: functions8,
-  make: make14
-};
-var blueprint_default8 = blueprint8;
-
-// src/blueprints/websearch/toolkit.ts
-import * as Toolkit3 from "@effect/ai/Toolkit";
 import * as AnthropicTool2 from "@effect/ai-anthropic/AnthropicTool";
-var WebSearchToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}));
-
-// src/blueprints/browser/blueprint.ts
-import { Blueprint as Blueprint9 } from "@dxos/blueprints";
-import { Ref as Ref20 } from "@dxos/echo";
-import { Text as Text9 } from "@dxos/schema";
-import { trim as trim12 } from "@dxos/util";
-var BLUEPRINT_KEY9 = "dxos.org/blueprint/browser";
-var instructions6 = trim12`
-  You are able to connect and use a virtual browser with persistent session.
-  Browser tools are provided via MCP.
-`;
-var make16 = () => Blueprint9.make({
-  key: BLUEPRINT_KEY9,
-  name: "Browser",
-  description: "Access to a real isolated browser.",
-  instructions: {
-    source: Ref20.make(Text9.make(instructions6))
-  },
-  mcpServers: [
-    {
-      // https://dash.cloudflare.com/950816f3f59b079880a1ae33fb0ec320/workers/services/view/playwright-mcp-example/production
-      url: "https://playwright-mcp-example.dxos.workers.dev/sse",
-      protocol: "sse"
-    }
-  ]
-});
-var blueprint9 = {
-  key: BLUEPRINT_KEY9,
-  make: make16,
-  functions: []
-};
-var blueprint_default9 = blueprint9;
-
-// src/blueprints/database/blueprint.ts
-import { Blueprint as Blueprint10 } from "@dxos/blueprints";
-import { Ref as Ref30 } from "@dxos/echo";
-import { Text as Text10 } from "@dxos/schema";
-import { trim as trim26 } from "@dxos/util";
-
-// src/blueprints/database/functions/context-add.ts
-import * as Effect17 from "effect/Effect";
-import * as Schema18 from "effect/Schema";
-import { AiContextService as AiContextService6 } from "@dxos/assistant";
-import { Obj as Obj17, Ref as Ref21 } from "@dxos/echo";
-import { defineFunction as defineFunction13 } from "@dxos/functions";
-import { trim as trim13 } from "@dxos/util";
-var context_add_default = defineFunction13({
-  key: "dxos.org/function/database/context-add",
-  name: "Add to context",
-  description: trim13`
-    Adds the object to the chat context.
-    Use this it for objects that are useful long-term for the conversation.
-  `,
-  inputSchema: Schema18.Struct({
-    obj: Ref21.Ref(Obj17.Unknown).annotations({
-      description: "Object to add to the chat context."
-    })
-  }),
-  outputSchema: Schema18.Void,
-  handler: Effect17.fn(function* ({ data: { obj } }) {
-    const { binder } = yield* AiContextService6;
-    yield* Effect17.promise(() => binder.bind({
-      blueprints: [],
-      objects: [
-        obj
-      ]
-    }));
-  }, AiContextService6.fixFunctionHandlerType)
-});
-
-// src/blueprints/database/functions/context-remove.ts
-import * as Effect18 from "effect/Effect";
-import * as Schema19 from "effect/Schema";
-import { AiContextService as AiContextService7 } from "@dxos/assistant";
-import { Obj as Obj18, Ref as Ref22 } from "@dxos/echo";
-import { defineFunction as defineFunction14 } from "@dxos/functions";
-import { trim as trim14 } from "@dxos/util";
-var context_remove_default = defineFunction14({
-  key: "dxos.org/function/database/context-remove",
-  name: "Remove from context",
-  description: trim14`
-    Removes the object from the chat context.
-    Use this it for objects that are no longer useful for the conversation.
-  `,
-  inputSchema: Schema19.Struct({
-    obj: Ref22.Ref(Obj18.Unknown).annotations({
-      description: "Object to remove from the chat context."
-    })
-  }),
-  outputSchema: Schema19.Void,
-  handler: Effect18.fn(function* ({ data: { obj } }) {
-    const { binder } = yield* AiContextService7;
-    yield* Effect18.promise(() => binder.unbind({
-      blueprints: [],
-      objects: [
-        obj
-      ]
-    }));
-  }, AiContextService7.fixFunctionHandlerType)
-});
-
-// src/blueprints/database/functions/load.ts
-import * as Array12 from "effect/Array";
-import * as Effect19 from "effect/Effect";
-import * as Schema20 from "effect/Schema";
-import { Database as Database16, Entity as Entity3, Obj as Obj19, Ref as Ref23 } from "@dxos/echo";
-import { defineFunction as defineFunction15 } from "@dxos/functions";
-import { trim as trim15 } from "@dxos/util";
-var load_default = defineFunction15({
-  key: "dxos.org/function/database/load",
-  name: "Load object",
-  description: trim15`
-    Loads the object or relation content.
-    Can load multiple objects at at time.
-    Use the to read the data when you have a DXN.
-    Call this tool with an array of one or more DXNs or object IDs.
-    When use see a reference ({ '/': 'dxn:...' }), you can call this function to load the object.
-    Note that returned data is only a snapshot in time, and might have changed since the object was last loaded.
-  `,
-  inputSchema: Schema20.Struct({
-    refs: Schema20.Array(Ref23.Ref(Obj19.Unknown))
-  }),
-  outputSchema: Schema20.Unknown,
-  handler: Effect19.fn(function* ({ data: { refs } }) {
-    return yield* Effect19.forEach(refs, Database16.load).pipe(Effect19.map(Array12.map(Entity3.toJSON)));
-  })
-});
-
-// src/blueprints/database/functions/object-create.ts
-import * as Effect20 from "effect/Effect";
-import * as Schema21 from "effect/Schema";
-import { Database as Database17, Entity as Entity4, Obj as Obj20, Type as Type6 } from "@dxos/echo";
-import { defineFunction as defineFunction16 } from "@dxos/functions";
-import { invariant as invariant4 } from "@dxos/invariant";
-import { trim as trim16 } from "@dxos/util";
-var __dxlog_file9 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/database/functions/object-create.ts";
-var object_create_default = defineFunction16({
-  key: "dxos.org/function/database/object-create",
-  name: "Create object",
-  description: trim16`
-    Creates a new object and adds it to the current space.
-    Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
-  `,
-  inputSchema: Schema21.Struct({
-    typename: Schema21.String,
-    data: Schema21.Any
-  }),
-  outputSchema: Schema21.Unknown,
-  handler: Effect20.fn(function* ({ data: { typename, data } }) {
-    const { db } = yield* Database17.Service;
-    const schema = yield* Effect20.promise(() => db.schemaRegistry.query({
-      typename,
-      location: [
-        "database",
-        "runtime"
-      ]
-    }).first());
-    invariant4(Type6.isObjectSchema(schema), "Schema is not an object schema", {
-      F: __dxlog_file9,
-      L: 30,
-      S: this,
-      A: [
-        "Type.isObjectSchema(schema)",
-        "'Schema is not an object schema'"
-      ]
-    });
-    const object = db.add(Obj20.make(schema, data));
-    return Entity4.toJSON(object);
-  })
-});
-
-// src/blueprints/database/functions/object-delete.ts
-import * as Effect21 from "effect/Effect";
-import * as Schema22 from "effect/Schema";
-import { Database as Database18, Obj as Obj21, Ref as Ref24 } from "@dxos/echo";
-import { defineFunction as defineFunction17 } from "@dxos/functions";
-import { trim as trim17 } from "@dxos/util";
-var object_delete_default = defineFunction17({
-  key: "dxos.org/function/database/object-delete",
-  name: "Delete object",
-  description: trim17`
-    Deletes the object.
-  `,
-  inputSchema: Schema22.Struct({
-    obj: Ref24.Ref(Obj21.Unknown)
-  }),
-  outputSchema: Schema22.Void,
-  handler: Effect21.fn(function* ({ data: { obj } }) {
-    const { db } = yield* Database18.Service;
-    const object = yield* Database18.load(obj);
-    db.remove(object);
-  })
-});
-
-// src/blueprints/database/functions/object-update.ts
-import * as Effect22 from "effect/Effect";
-import * as Schema23 from "effect/Schema";
-import { Database as Database19, Entity as Entity5, Obj as Obj22, Ref as Ref25 } from "@dxos/echo";
-import { defineFunction as defineFunction18 } from "@dxos/functions";
-import { trim as trim18 } from "@dxos/util";
-var object_update_default = defineFunction18({
-  key: "dxos.org/function/database/object-update",
-  name: "Update object",
-  description: trim18`
-    Updates the object properties.
-  `,
-  inputSchema: Schema23.Struct({
-    obj: Ref25.Ref(Obj22.Unknown),
-    properties: Schema23.Record({
-      key: Schema23.String,
-      value: Schema23.Any
-    })
-  }),
-  outputSchema: Schema23.Unknown,
-  handler: Effect22.fn(function* ({ data: { obj, properties } }) {
-    const object = yield* Database19.load(obj);
-    Entity5.change(object, (obj2) => {
-      for (const [key, value] of Object.entries(properties)) {
-        obj2[key] = value;
-      }
-    });
-    return Entity5.toJSON(object);
-  })
-});
-
-// src/blueprints/database/functions/query.ts
-import * as Effect23 from "effect/Effect";
-import * as Schema24 from "effect/Schema";
-import { Entity as Entity6, Filter as Filter4, Obj as Obj23, Query as Query5 } from "@dxos/echo";
-import { Database as Database20 } from "@dxos/echo";
-import { defineFunction as defineFunction19 } from "@dxos/functions";
-import { trim as trim19 } from "@dxos/util";
-var query_default = defineFunction19({
-  key: "dxos.org/function/database/query",
-  name: "Query",
-  description: trim19`
-      Query for objects in ECHO.
-      Use this tool when searching for information in the space (both automerge and queues).
-      Currently, two types of queries are supported:
-        - Full-text search - terms may appear anywhere in the object.
-        - Type-based search - objects of a specific type.
-      You can use them together, for example, to search for objects of a specific type that match a full-text query.
-      Important: Whem querying by typename, make sure to list the schema first, to get the exact typename.
-
-      Omit both typename and text to search for all objects.
-
-      <output_format>
-        You can choose to either return the full object data, or just the DXN, type and label.
-        When expecting a lot of results, run with includeContent=false to not pollute the context, and then load specific objects using the load tool.
-
-        You can choose to get the content right away, if you don't expect a lot of results.
-        To load content right away, run with includeContent=true.
-        When loading content, set an appropriate limit on the number of results to avoid overwhelming the context.
-      </output_format>
-
-      <example description="All tasks related to Cyberdyne and Bob">
-        {
-          "typename": "dxos.org/type/Task",
-          "text": "cyberdyne bob",
-        }
-      </example>
-
-      <example description="Financial report Q1 2026">
-        {
-          "typename": "dxos.org/type/Document",
-          "text": "financial report Q1 2026",
-          "includeContent": true
-          "limit": 3
-        }
-      </example>
-    `,
-  inputSchema: Schema24.Struct({
-    typename: Schema24.optional(Schema24.String.annotations({
-      description: "The typename of the objects to list.",
-      example: "dxos.org/type/Task"
-    })),
-    text: Schema24.optional(Schema24.String.annotations({
-      description: "Full text search query.",
-      example: "email cyberdyne bob"
-    })),
-    includeContent: Schema24.optional(Schema24.Boolean.annotations({
-      description: "Include the full object data in the response.",
-      default: false
-    })),
-    limit: Schema24.optional(Schema24.Number.annotations({
-      description: "The maximum number of results to return.",
-      default: 10
-    })),
-    // TODO(dmaretskyi): There's a problem with querying queues, that the agent keeps finding message from agent threads.
-    //                   Let's think about a better way to do this.
-    //                   And queues don't have predicatble ids, so queue DXNs blow up the conversation cache.
-    includeQueues: Schema24.optional(Schema24.Boolean.annotations({
-      description: "Search in queues as well as spaces. Only use this if searching for emails.",
-      default: false
-    }))
-  }),
-  outputSchema: Schema24.Array(Schema24.Unknown),
-  handler: Effect23.fn(function* ({ data: { typename, text, includeContent = false, limit = 10, includeQueues = false } }) {
-    let query2;
-    if (text) {
-      query2 = Query5.all(...text.split(" ").map((term) => Query5.select(Filter4.text(term, {
-        type: "full-text"
-      }))));
-      if (typename !== void 0) {
-        const schema = yield* Database20.runSchemaQuery({
-          typename,
-          location: [
-            "database",
-            "runtime"
-          ]
-        });
-        if (schema.length === 0) {
-          return yield* Effect23.fail(new Error(`Schema ${typename} not found`));
-        }
-        query2 = query2.select(Filter4.type(schema[0]));
-      }
-    } else if (typename) {
-      query2 = Query5.select(Filter4.type(typename));
-    } else {
-      query2 = Query5.select(Filter4.everything());
-    }
-    query2 = query2.limit(limit);
-    if (includeQueues) {
-      query2 = query2.from({
-        allQueuesFromSpaces: true
-      });
-    }
-    yield* Database20.flush({
-      indexes: true
-    });
-    const results = yield* Database20.runQuery(query2);
-    if (includeContent) {
-      return results.map((obj) => Entity6.toJSON(obj));
-    } else {
-      return results.map((obj) => ({
-        dxn: Obj23.getDXN(obj).toString(),
-        typename: Obj23.getTypename(obj),
-        label: Obj23.getLabel(obj)
-      }));
-    }
-  })
-});
-
-// src/blueprints/database/functions/relation-create.ts
-import * as Effect24 from "effect/Effect";
-import * as Schema25 from "effect/Schema";
-import { Database as Database21, Entity as Entity7, Obj as Obj24, Ref as Ref26, Relation as Relation3, Type as Type7 } from "@dxos/echo";
-import { defineFunction as defineFunction20 } from "@dxos/functions";
-import { invariant as invariant5 } from "@dxos/invariant";
-import { trim as trim20 } from "@dxos/util";
-var __dxlog_file10 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/blueprints/database/functions/relation-create.ts";
-var relation_create_default = defineFunction20({
-  key: "dxos.org/function/database/relation-create",
-  name: "Create relation",
-  description: trim20`
-    Creates a new relation and adds it to the current space.
-    Get the schema from the schema-list tool and ensure that the data matches the corresponding schema.
-  `,
-  inputSchema: Schema25.Struct({
-    typename: Schema25.String,
-    source: Ref26.Ref(Obj24.Unknown),
-    target: Ref26.Ref(Obj24.Unknown),
-    properties: Schema25.Any.annotations({
-      description: "The data to be stored in the relation."
-    })
-  }),
-  outputSchema: Schema25.Unknown,
-  handler: Effect24.fn(function* ({ data: { typename, source, target, properties } }) {
-    const { db } = yield* Database21.Service;
-    const schema = yield* Effect24.promise(() => db.schemaRegistry.query({
-      typename,
-      location: [
-        "database",
-        "runtime"
-      ]
-    }).first());
-    invariant5(Type7.isRelationSchema(schema), "Schema is not a relation schema", {
-      F: __dxlog_file10,
-      L: 34,
-      S: this,
-      A: [
-        "Type.isRelationSchema(schema)",
-        "'Schema is not a relation schema'"
-      ]
-    });
-    const sourceObj = yield* Database21.load(source);
-    const targetObj = yield* Database21.load(target);
-    const relation = db.add(Relation3.make(schema, {
-      [Relation3.Source]: sourceObj,
-      [Relation3.Target]: targetObj,
-      ...properties
-    }));
-    return Entity7.toJSON(relation);
-  })
-});
-
-// src/blueprints/database/functions/relation-delete.ts
-import * as Effect25 from "effect/Effect";
-import * as Schema26 from "effect/Schema";
-import { Database as Database22, Ref as Ref27, Relation as Relation4 } from "@dxos/echo";
-import { defineFunction as defineFunction21 } from "@dxos/functions";
-import { trim as trim21 } from "@dxos/util";
-var relation_delete_default = defineFunction21({
-  key: "dxos.org/function/database/relation-delete",
-  name: "Delete relation",
-  description: trim21`
-    Deletes the relation.
-  `,
-  inputSchema: Schema26.Struct({
-    rel: Ref27.Ref(Relation4.Unknown)
-  }),
-  outputSchema: Schema26.Void,
-  handler: Effect25.fn(function* ({ data: { rel } }) {
-    const { db } = yield* Database22.Service;
-    const relation = yield* Database22.load(rel);
-    db.remove(relation);
-  })
-});
-
-// src/blueprints/database/functions/schema-add.ts
-import * as Effect26 from "effect/Effect";
-import * as Schema27 from "effect/Schema";
-import { Database as Database23 } from "@dxos/echo";
-import { defineFunction as defineFunction22 } from "@dxos/functions";
-import { trim as trim22 } from "@dxos/util";
-var schema_add_default = defineFunction22({
-  key: "dxos.org/function/database/schema-add",
-  name: "Add schema",
-  description: trim22`
-    Adds a schema to the space.
-    The name will be used when displayed to the user.
-  `,
-  inputSchema: Schema27.Struct({
-    name: Schema27.String,
-    typename: Schema27.String.annotations({
-      description: 'The typename of the schema in the format of "example.com/type/Type".'
-    }),
-    jsonSchema: Schema27.Any
-  }),
-  outputSchema: Schema27.Void,
-  handler: Effect26.fn(function* ({ data: { name, typename, jsonSchema } }) {
-    const { db } = yield* Database23.Service;
-    yield* Effect26.promise(() => db.schemaRegistry.register([
-      {
-        typename,
-        version: "0.1.0",
-        jsonSchema,
-        name
-      }
-    ]));
-  })
-});
-
-// src/blueprints/database/functions/schema-list.ts
-import * as Effect27 from "effect/Effect";
-import * as Schema28 from "effect/Schema";
-import { Database as Database24, JsonSchema, Type as Type8 } from "@dxos/echo";
-import { defineFunction as defineFunction23 } from "@dxos/functions";
-import { trim as trim23 } from "@dxos/util";
-var schema_list_default = defineFunction23({
-  key: "dxos.org/function/database/schema-list",
-  name: "List schemas",
-  description: trim23`
-    Lists schemas definitions.
-  `,
-  inputSchema: Schema28.Struct({
-    limit: Schema28.optional(Schema28.Number)
-  }),
-  outputSchema: Schema28.Array(Schema28.Unknown),
-  handler: Effect27.fn(function* () {
-    const { db } = yield* Database24.Service;
-    const schema = yield* Effect27.promise(() => db.schemaRegistry.query({
-      location: [
-        "database",
-        "runtime"
-      ]
-    }).run());
-    return schema.map((schema2) => {
-      const meta = Type8.getMeta(schema2);
-      return {
-        typename: Type8.getTypename(schema2),
-        jsonSchema: JsonSchema.toJsonSchema(schema2),
-        kind: meta?.sourceSchema ? "relation" : "record"
-      };
-    });
-  })
-});
-
-// src/blueprints/database/functions/tag-add.ts
-import * as Effect28 from "effect/Effect";
-import * as Schema29 from "effect/Schema";
-import { Database as Database25, Entity as Entity8, Obj as Obj25, Ref as Ref28, Tag as Tag2 } from "@dxos/echo";
-import { defineFunction as defineFunction24 } from "@dxos/functions";
-import { trim as trim24 } from "@dxos/util";
-var tag_add_default = defineFunction24({
-  key: "dxos.org/function/database/tag-add",
-  name: "Add tag",
-  description: trim24`
-    Adds a tag to an object.
-    Tags are objects of type ${Tag2.Tag.typename}.
-    You must search database for available tags, or create a new one.
-  `,
-  inputSchema: Schema29.Struct({
-    tag: Ref28.Ref(Obj25.Unknown),
-    obj: Ref28.Ref(Obj25.Unknown)
-  }),
-  outputSchema: Schema29.Unknown,
-  handler: Effect28.fn(function* ({ data: { tag, obj } }) {
-    const object = yield* Database25.load(obj);
-    const tagObj = yield* Database25.load(tag);
-    Entity8.change(object, (obj2) => Entity8.addTag(obj2, Obj25.getDXN(tagObj).toString()));
-    return Entity8.toJSON(object);
-  })
-});
-
-// src/blueprints/database/functions/tag-remove.ts
-import * as Effect29 from "effect/Effect";
-import * as Schema30 from "effect/Schema";
-import { Database as Database26, Entity as Entity9, Obj as Obj26, Ref as Ref29, Tag as Tag3 } from "@dxos/echo";
-import { defineFunction as defineFunction25 } from "@dxos/functions";
-import { trim as trim25 } from "@dxos/util";
-var tag_remove_default = defineFunction25({
-  key: "dxos.org/function/database/tag-remove",
-  name: "Remove tag",
-  description: trim25`
-    Removes a tag from an object.
-    Tags are objects of type ${Tag3.Tag.typename}.
-  `,
-  inputSchema: Schema30.Struct({
-    tag: Ref29.Ref(Obj26.Unknown),
-    obj: Ref29.Ref(Obj26.Unknown)
-  }),
-  outputSchema: Schema30.Unknown,
-  handler: Effect29.fn(function* ({ data: { tag, obj } }) {
-    const object = yield* Database26.load(obj);
-    const tagObj = yield* Database26.load(tag);
-    Entity9.change(object, (obj2) => Entity9.removeTag(obj2, Obj26.getDXN(tagObj).toString()));
-    return Entity9.toJSON(object);
-  })
-});
-
-// src/blueprints/database/functions/index.ts
-var DatabaseFunctions = {
-  ContextAdd: context_add_default,
-  ContextRemove: context_remove_default,
-  Load: load_default,
-  ObjectCreate: object_create_default,
-  ObjectDelete: object_delete_default,
-  ObjectUpdate: object_update_default,
-  Query: query_default,
-  RelationCreate: relation_create_default,
-  RelationDelete: relation_delete_default,
-  SchemaAdd: schema_add_default,
-  SchemaList: schema_list_default,
-  TagAdd: tag_add_default,
-  TagRemove: tag_remove_default
-};
-
-// src/blueprints/database/blueprint.ts
-var BLUEPRINT_KEY10 = "dxos.org/blueprint/database";
-var instructions7 = trim26`
-  You can query, create, update, and delete objects in ECHO.
-  You can manage schemas, relations, tags, and add objects to the chat context.
-`;
-var functions9 = Object.values(DatabaseFunctions);
-var make17 = () => Blueprint10.make({
-  key: BLUEPRINT_KEY10,
-  name: "Database",
-  description: "Query and manipulate objects in the ECHO database.",
-  instructions: {
-    source: Ref30.make(Text10.make(instructions7))
-  },
-  tools: Blueprint10.toolDefinitions({
-    functions: functions9
-  })
-});
-var blueprint10 = {
-  key: BLUEPRINT_KEY10,
-  functions: functions9,
-  make: make17
-};
-var blueprint_default10 = blueprint10;
-
-// src/functions/agent/prompt.ts
-import * as Array16 from "effect/Array";
-import * as Effect30 from "effect/Effect";
-import * as Function6 from "effect/Function";
-import * as Option4 from "effect/Option";
-import * as Schema31 from "effect/Schema";
-import { AiService as AiService4, ConsolePrinter as ConsolePrinter2, ModelName } from "@dxos/ai";
-import { AiSession as AiSession2, GenerationObserver as GenerationObserver2, createToolkit as createToolkit2 } from "@dxos/assistant";
-import { Prompt as Prompt2, Template as Template3 } from "@dxos/blueprints";
-import { Database as Database27, Obj as Obj27, Ref as Ref31 } from "@dxos/echo";
-import { TracingService as TracingService4, defineFunction as defineFunction26 } from "@dxos/functions";
-import { log as log6 } from "@dxos/log";
-var __dxlog_file11 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/functions/agent/prompt.ts";
-var DEFAULT_MODEL = "@anthropic/claude-opus-4-0";
-var prompt_default = defineFunction26({
-  key: "dxos.org/function/prompt",
-  name: "Agent",
-  description: "Agentic worker that executes a provided prompt using blueprints and tools.",
-  inputSchema: Schema31.Struct({
-    prompt: Ref31.Ref(Prompt2.Prompt),
-    systemPrompt: Schema31.optional(Ref31.Ref(Prompt2.Prompt)),
-    /**
-    * @default @anthropic/claude-opus-4-0
-    */
-    model: Schema31.optional(ModelName),
-    /**
-    * Input object or data.
-    * References get auto-resolved.
-    */
-    input: Schema31.Any.pipe(Schema31.annotations({
-      title: "Input"
-    }))
-  }),
-  outputSchema: Schema31.Any,
-  handler: Effect30.fnUntraced(function* ({ data }) {
-    log6.info("processing input", {
-      input: data.input
-    }, {
-      F: __dxlog_file11,
-      L: 39,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const input = yield* Ref31.isRef(data.input) ? Database27.load(data.input).pipe(Effect30.map(Obj27.toJSON)) : Effect30.succeed(data.input);
-    yield* Database27.flush({
-      indexes: true
-    });
-    const prompt = yield* Database27.load(data.prompt);
-    const systemPrompt = data.systemPrompt ? yield* Database27.load(data.systemPrompt) : void 0;
-    yield* TracingService4.emitStatus({
-      message: `Running ${prompt.id}`
-    });
-    log6.info("starting agent", {
-      prompt: prompt.id,
-      input
-    }, {
-      F: __dxlog_file11,
-      L: 63,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const blueprints = yield* Function6.pipe(prompt.blueprints, Array16.appendAll(systemPrompt?.blueprints ?? []), Effect30.forEach(Database27.loadOption), Effect30.map(Array16.filter(Option4.isSome)), Effect30.map(Array16.map((option) => option.value)));
-    const toolkit = yield* createToolkit2({
-      blueprints
-    });
-    const objects = yield* Function6.pipe(prompt.context, Array16.appendAll(systemPrompt?.context ?? []), Effect30.forEach(Database27.loadOption), Effect30.map(Array16.filter(Option4.isSome)), Effect30.map(Array16.map((option) => option.value)));
-    const promptInstructions = yield* Database27.load(prompt.instructions.source);
-    const promptText = Template3.process(promptInstructions.content, input);
-    const systemInstructions = systemPrompt ? yield* Database27.load(systemPrompt.instructions.source) : void 0;
-    const systemText = systemInstructions ? Template3.process(systemInstructions.content, {}) : void 0;
-    const session = new AiSession2();
-    const result = yield* session.run({
-      prompt: promptText,
-      system: systemText,
-      blueprints,
-      objects,
-      toolkit,
-      observer: GenerationObserver2.fromPrinter(new ConsolePrinter2({
-        tag: "agent"
-      }))
-    }).pipe(Effect30.provide(AiService4.model(data.model ?? DEFAULT_MODEL)));
-    const lastBlock = result.at(-1)?.blocks.filter((block) => block._tag === "text").at(-1);
-    return {
-      note: lastBlock?.text
-    };
-  })
-});
-
-// src/functions/agent/index.ts
-var AgentFunctions = {
-  Prompt: prompt_default
-};
-
-// src/functions/entity-extraction/entity-extraction.ts
-import * as Effect31 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-import * as Predicate from "effect/Predicate";
-import * as Schema32 from "effect/Schema";
-import { AiService as AiService5 } from "@dxos/ai";
-import { GenericToolkit as GenericToolkit2 } from "@dxos/ai";
-import { AiSession as AiSession3, ToolExecutionServices as ToolExecutionServices2 } from "@dxos/assistant";
-import { Database as Database28, Filter as Filter5, Obj as Obj28, Ref as Ref32 } from "@dxos/echo";
-import { defineFunction as defineFunction27 } from "@dxos/functions";
-import { FunctionInvocationServiceLayerTest } from "@dxos/functions-runtime/testing";
-import { log as log7 } from "@dxos/log";
-import { LegacyOrganization as LegacyOrganization2, Message as Message2, Organization, Person as Person3 } from "@dxos/types";
-import { trim as trim27 } from "@dxos/util";
-var __dxlog_file12 = "/__w/dxos/dxos/packages/core/assistant-toolkit/src/functions/entity-extraction/entity-extraction.ts";
-var entity_extraction_default = defineFunction27({
-  key: "dxos.org/functions/entity-extraction",
-  name: "Entity Extraction",
-  description: "Extracts entities from emails and transcripts.",
-  inputSchema: Schema32.Struct({
-    source: Message2.Message.annotations({
-      description: "Email or transcript to extract entities from."
-    }),
-    // TODO(dmaretskyi): Consider making this an array of blueprints instead.
-    instructions: Schema32.optional(Schema32.String).annotations({
-      description: "Instructions extraction process."
-    })
-  }),
-  outputSchema: Schema32.Struct({
-    entities: Schema32.optional(Schema32.Array(Obj28.Unknown).annotations({
-      description: "Extracted entities."
-    }))
-  }),
-  handler: Effect31.fnUntraced(function* ({ data: { source: message, instructions: instructions8 } }) {
-    const tags = Obj28.getMeta(message)?.tags;
-    const contact = yield* extractContact(message.sender, tags);
-    let organization = null;
-    if (contact && !contact.organization) {
-      const created = [];
-      const GraphWriterToolkit = makeGraphWriterToolkit({
-        schema: [
-          LegacyOrganization2
-        ]
-      }).pipe();
-      const GraphWriterHandler = makeGraphWriterHandler(GraphWriterToolkit, {
-        onAppend: (dxns) => created.push(...dxns)
-      });
-      const toolkit = yield* GraphWriterToolkit.pipe(Effect31.provide(GraphWriterHandler.pipe(Layer4.provide(ResearchGraph_exports.contextQueueLayer))));
-      yield* new AiSession3().run({
-        system: trim27`
-            Extract the sender's organization from the email. If you are not sure, do nothing.
-            The extracted organization URL must match the sender's email domain.
-            ${instructions8 ? "<user_intructions>" + instructions8 + "</user_intructions>" : ""},
-          `,
-        prompt: JSON.stringify({
-          source: message,
-          contact
-        }),
-        toolkit
-      });
-      if (created.length > 1) {
-        throw new Error("Multiple organizations created");
-      } else if (created.length === 1) {
-        organization = yield* Database28.resolve(created[0], Organization.Organization);
-        Obj28.change(organization, (org) => {
-          const meta = Obj28.getMeta(org);
-          meta.tags ??= [];
-          meta.tags.push(...tags ?? []);
-        });
-        Obj28.change(contact, (c) => {
-          c.organization = Ref32.make(organization);
-        });
-      }
-    }
-    return {
-      entities: [
-        contact,
-        organization
-      ].filter(Predicate.isNotNullable)
-    };
-  }, Effect31.provide(Layer4.mergeAll(AiService5.model("@anthropic/claude-sonnet-4-0"), ToolExecutionServices2).pipe(Layer4.provide(
-    // TODO(dmaretskyi): This should be provided by environment.
-    Layer4.mergeAll(GenericToolkit2.providerEmpty, FunctionInvocationServiceLayerTest())
-  ))))
-});
-var extractContact = Effect31.fn("extractContact")(function* (actor, tags) {
-  const name = actor.name;
-  const email = actor.email;
-  if (!email) {
-    log7.warn("email is required for contact extraction", {
-      actor
-    }, {
-      F: __dxlog_file12,
-      L: 110,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return void 0;
-  }
-  const existingContacts = yield* Database28.runQuery(Filter5.type(Person3.Person));
-  const existingContact = existingContacts.find((contact) => contact.emails?.some((contactEmail) => contactEmail.value === email));
-  if (existingContact) {
-    log7.info("Contact already exists", {
-      email,
-      existingContact
-    }, {
-      F: __dxlog_file12,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return existingContact;
-  }
-  const newContact = Obj28.make(Person3.Person, {
-    ...tags ? {
-      [Obj28.Meta]: {
-        tags: [
-          ...tags
-        ]
-      }
-    } : {},
-    emails: [
-      {
-        value: email
-      }
-    ]
-  });
-  yield* Database28.add(newContact);
-  if (name) {
-    Obj28.change(newContact, (c) => {
-      c.fullName = name;
-    });
-  }
-  const emailDomain = email.split("@")[1]?.toLowerCase();
-  if (!emailDomain) {
-    log7.warn("Invalid email format, cannot extract domain", {
-      email
-    }, {
-      F: __dxlog_file12,
-      L: 141,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    return newContact;
-  }
-  log7.info("extracted email domain", {
-    emailDomain
-  }, {
-    F: __dxlog_file12,
-    L: 145,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  const existingOrganisations = yield* Database28.runQuery(Filter5.type(Organization.Organization));
-  const matchingOrg = existingOrganisations.find((org) => {
-    if (org.website) {
-      try {
-        const websiteUrl = org.website.startsWith("http://") || org.website.startsWith("https://") ? org.website : `https://${org.website}`;
-        const websiteDomain = new URL(websiteUrl).hostname.toLowerCase();
-        return websiteDomain === emailDomain || websiteDomain.endsWith(`.${emailDomain}`) || emailDomain.endsWith(`.${websiteDomain}`);
-      } catch (e) {
-        log7.warn("Error parsing website URL", {
-          website: org.website,
-          error: e
-        }, {
-          F: __dxlog_file12,
-          L: 163,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return false;
-      }
-    }
-    return false;
-  });
-  if (matchingOrg) {
-    log7.info("found matching organization", {
-      organization: matchingOrg
-    }, {
-      F: __dxlog_file12,
-      L: 174,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    Obj28.change(newContact, (c) => {
-      c.organization = Ref32.make(matchingOrg);
-    });
-  }
-  return newContact;
-});
-
-// src/functions/entity-extraction/index.ts
-var EntityExtractionFunctions = {
-  Extract: entity_extraction_default
-};
-
-// src/functions/exa/exa.ts
-import * as Effect32 from "effect/Effect";
-import * as Schema33 from "effect/Schema";
-import Exa from "exa-js";
-import { CredentialsService as CredentialsService3, defineFunction as defineFunction28 } from "@dxos/functions";
-var exa_default = defineFunction28({
-  key: "dxos.org/function/exa-search",
-  name: "Exa Search",
-  description: "Search the web for information",
-  inputSchema: Schema33.Struct({
-    query: Schema33.String.annotations({
-      description: "The query to search for."
-    })
-  }),
-  outputSchema: Schema33.Unknown,
-  handler: Effect32.fnUntraced(function* ({ data: { query: query2 } }) {
-    const credential = yield* CredentialsService3.getCredential({
-      service: "exa.ai"
-    });
-    const exa = new Exa(credential.apiKey);
-    const context = yield* Effect32.promise(async () => exa.searchAndContents(query2, {
-      type: "auto",
-      text: {
-        maxCharacters: 3e3
-      },
-      livecrawl: "always"
-    }));
-    return context;
-  })
-});
-
-// src/functions/exa/mock.ts
-import * as Effect33 from "effect/Effect";
-import * as Schema34 from "effect/Schema";
-import { defineFunction as defineFunction29 } from "@dxos/functions";
-
-// src/functions/exa/data/exa-search-1748337321991.ts
-var exa_search_1748337321991_default = {
-  requestId: "324936368a74f4db978982172bc18a6c",
-  autopromptString: "AI personal knowledge management tools projects 2024",
-  autoDate: "2024-01-01T00:00:00.000Z",
-  resolvedSearchType: "neural",
-  results: [
-    {
-      id: "https://www.open-notebook.ai/",
-      title: "What is Open Notebook? | Open Notebook",
-      url: "https://www.open-notebook.ai/",
-      publishedDate: "2024-01-01T00:00:00.000Z",
-      author: "",
-      score: 0.3995794951915741,
-      text: "Take Control of Your Learning. Privately. A powerful open-source, AI-powered note-taking/research platform that respects your privacy \u{1F399}\uFE0F Podcast Generator Transform your notes into engaging podcasts with customizable voices, speakers, and episodes \u{1F916} AI-Powered Notes Leverage AI to summarize, generate insights, and manage your notes \u{1F512} Privacy Control Full control over what information AI can access \u{1F504} Content Integration Support for links, PDFs, TXT, PPT, YouTube, and more What is Open Notebook? \u200B Open Notebook is the cognitive partner you always wanted and could never explain why. It combines the power of AI with unwavering privacy controls. It's designed for researchers, students, and professionals who want to enhance their learning and abilities while maintaining complete control over workflows, models, and how their data gets used and exposed. Is this right for me? \u200B \u{1F4DA} Learning Enthusiast You're constantly seeking knowledge and want to go beyond surface-level understanding. Learning for you is about building deep, lasting comprehension. \u{1F91D} You want a learning partner You believe your learning process can improve by partnering with a tailor made AI. You want to be provoked to think more clearly. \u{1F92F} Your learning backlog is way too big You have hundreds of links you would love to read, but there is no time for it all. You want to make sure those are catalogued for when you need them. \u270D\uFE0F Independent Thinker You value both taking notes and forming your own ideas. You understand different viewpoints but believe in developing your own perspective. \u{1F512} You are privacy aware You don't want all your context, thoughts and plans to be all over Big Tech, if not necessary. \u{1F481} You like things your way You want to decide how your content is handled, which AI models you want to interact with and help specifically it should help/challenge you. What is the plan for the future? \u200B There is much more that can be done to augment human knowledge. Open Notebook's first release is just a first step in that direction. The end goal is to build a Cognitive Partner for every person. A customized assistant that can help you develop your skills, knowledge, and opinions in a way that makes sense to you. Learn more about our long-term vision and roadmap in our Vision page."
-    },
-    {
-      id: "https://www.reorproject.org/",
-      title: "Reor",
-      url: "https://www.reorproject.org/",
-      publishedDate: "2024-01-01T00:00:00.000Z",
-      author: "Reor",
-      score: 0.39665618538856506,
-      text: "Private &amp; local AI personal knowledge management app for high entropy thinkers. Q&amp;A Chat with an LLM that has full context of your notes. Automatically connected ideas Never manually link your notes again. Semantic Search Search without having to remember exact phrasing. WYSIWYG Markdown Markdown is the language of thought. Local First LLMs, Embedding Models, Vector database. Everything runs and stores locally. Writing Assistant Write with the world's first local writing assistant. Trusted by individuals who may have heard of these companies",
-      image: "https://reorhomepage-2-cwy0zagzg-reor-team.vercel.app/opengraph-image.jpg?a25ca70e900445ed",
-      favicon: "https://www.reorproject.org/favicon-16x16.png"
-    },
-    {
-      id: "https://mymemo.ai/blog/best-ai-personal-knowledge-management-tools-in-2024/detail",
-      title: "Best AI Personal Knowledge Management (PKM) tools in 2024 - My Framer Site",
-      url: "https://mymemo.ai/blog/best-ai-personal-knowledge-management-tools-in-2024/detail",
-      publishedDate: "2025-05-21T17:17:02.000Z",
-      author: "",
-      score: 0.3811739385128021,
-      text: "In today's fast-paced world, managing and organizing knowledge has become increasingly challenging. With the rise of digital information and the need for efficient knowledge sharing, traditional methods of knowledge management are no longer sufficient. AI-powered tools have emerged as a game-changer in this domain, offering a more efficient and effective way to manage and organize knowledge. Efficiency Amplified: AI streamlines the organization and analysis of vast data sets, saving time and reducing manual effort. Insights Unearthed: Uncover hidden patterns, trends, and valuable insights within your data, providing a deeper understanding of your information. Personalized Experience: Tailor your knowledge management approach with AI, creating a personalized digital assistant that adapts to your unique needs. Stay Ahead in the Digital Era: Embrace the transformative power of AI to navigate the information overload and stay ahead in our rapidly evolving digital landscape. Here are 10 AI-powered tools for personal knowledge management with their product links: 1. MyMemo AI: - Introduction: MyMemo transforms personal data into wisdom using AI, offering features like targeted search, smart advice, and creative writing prompts. - Product Link: [MyMemo Website](https://www.mymemo.ai) - Features: - Collects digital knowledge from various sources into a single platform. - Processes collected information with AI to extract key insights. - Allows users to query MyMemoAI for specific info or insights from their knowledge base. - Offers targeted search, smart advice, and creative writing prompts for enhanced knowledge management. 2. Notion AI: - Introduction: Notion AI offers a customizable workspace for efficient knowledge sharing and management. - Product Link: [Notion AI Website](https://www.notion.so) - Features: - Customizable workspace for knowledge sharing. - Integration with various tools like Slack, Google Drive, and Microsoft Teams. - Robust search capabilities powered by AI and AI-based analytics. 3. ClickUp: - Introduction: ClickUp provides dedicated spaces for knowledge base organization and seamless integration with various tools. - Product Link: [ClickUp Website](https://clickup.com) - Features: - Dedicated spaces for Knowledge Base organization. - Integration with third-party software like Microsoft Teams, Jira, Slack, Zoho, and more. - AI-based analytics to track productivity and identify patterns. 4. MyMind: - Introduction: MyMind offers a private space to save notes, images, quotes, and highlights enhanced by AI to aid in memory recall without the need for manual categorization. - Product Link: [MyMind Website](https://www.mymind.com) - Features: - Private space for saving notes, images, quotes, and highlights. - Enhanced by AI for efficient memory recall without manual organization. - Tailored for designers, writers, researchers, developers, and visual minds of all kinds. Adding Mem.ai to the top 10 list of AI-powered tools for personal kn",
-      image: "https://framerusercontent.com/images/xtRTZ9zRVH3uL1fvH2vqA6G60W8.png",
-      favicon: "https://framerusercontent.com/images/XEQTxAwueP1wc7BpbB1zrouiuoA.png"
-    },
-    {
-      id: "https://mymemo.ai/",
-      title: "MyMemo-Empower Your Mind with AI",
-      url: "https://mymemo.ai/",
-      publishedDate: "2025-05-21T17:17:02.000Z",
-      author: "",
-      score: 0.3810442090034485,
-      text: "End Digital Chaos with All In One Digital Space Effortlessly Access Information with AI Chat What have I uploaded about the marketing strategy? How to raise fund as a founder for startup\uFF1F Write an article about the impact of AI in our society. Compliance with Global Standards MyMemo AI adheres to international data protection regulations, ensuring your data is handled with the utmost care. Secure Storage Your data is encrypted and stored on our high-security servers, ensuring that only you have access. We maintain strict privacy protocols, and even our team cannot view your information. Private Links for Your Memos MyMemo AI ensures that all links generated for your uploaded content are private and exclusively visible to you.\xA0 100 AI chat per month 100 content uploads per month 5 memo collections Powered by GPT-4o mini Up to 5 Related Memo in AI chat Single PDF file size under 5MB 10 AI writing for notes in total AI chat unlimited 1000 content uploads per month 100 Memo Collections Supports multiple AI models Up to 5 Related Memo in AI chat Single PDF file size under 30MB 100 AI writing for notes per month Custom AI summary prompt(coming soon) AI chat unlimited Unlimited content uploads Unlimited memo collections Supports multiple AI models Up to 8 Related Memo in AI chat Single PDF file size under 50MB Unlimited AI writing for notes Custom AI summary prompt(coming soon) Free access to @GPT-4o in Chat We\u2019re excited to\xA0partner with Inkwise\xA0to bring MyMemo users an exclusive deal! Inkwise.ai is an AI-powered platform that helps users craft professional documents by extracting and integrating key information from uploaded files. It offers industry-specific templates, intelligent content extraction, and a referencing system that ensures factual accuracy. Exclusive for MyMemo Users: Get\xA0 2 months of Inkwise Pro for free \xA0with the code\xA0 INKWISE2025 \xA0at checkout! MyMemo \xA9 MyMemo 2025. All rights reserved",
-      image: "https://framerusercontent.com/images/xtRTZ9zRVH3uL1fvH2vqA6G60W8.png",
-      favicon: "https://framerusercontent.com/images/XEQTxAwueP1wc7BpbB1zrouiuoA.png"
-    },
-    {
-      id: "https://www.personal.ai/memory",
-      title: "Make Your Own AI with Your Unique Memory",
-      url: "https://www.personal.ai/memory",
-      publishedDate: "2024-01-01T00:00:00.000Z",
-      author: "",
-      score: 0.3991696536540985,
-      text: "In Personal AI, version control for memory and model is managed through a systematic approach that allows users to track, manage, and revert changes made to the AI's memory and model. \u200D Memory Stack: When you store a memory in Personal AI, it goes into the memory stack for training the AI. \u200D Data Uploads: Users can add, edit, or reinforce memories by uploading authored data directly into their personal language model. \u200D The personal language model has unlimited memory and is not bound by token or context limitations. The AI's performance is as good as the memory provided to it. If it makes false statements, the memory needs to be fixed and reinforced for future learning. There will be mechanisms to download the memory and model in the future. The output of the personal AI model is entirely controlled by the user's input and training. Yes, you can automate conversations using stacked memories in your Personal AI. By leveraging the memory stacking feature, you can train your AI to recall and utilize specific information during interactions \u200D Practices for Automating Conversations: Memory Anchors: When stacking new memories, consider adding memory anchors to organize the information effectively. This practice helps structure and categorize the data within your Personal AI account. Variety of Sources: Utilize all available tools such as the chat box, document editor, file uploader, and URL uploader to stack data from various sources. This diverse input enables your AI to learn from a wide range of inputs for a more personalized experience. \u200D Application of Practices: To automate conversations effectively, ensure that you consistently add relevant information into your memory stack using different tools provided by Personal AI. By doing so, you enable your AI to access and utilize this knowledge when engaging in digital interactions on your behalf. Yes, you can absolutely use hashtags to label and recall specific memories later on with your Personal AI. When adding memories to your AI, it's beneficial to include detailed and descriptive information about the topic or subject, along with context such as people, location, and absolute time for the AI to reference. Using hashtags allows you to categorize and organize these memories effectively. By using proper placement of hashtags without spaces and maintaining uniform capitalization, you can enhance the selection of memories for generating answers. Additionally, when stacking content using the chat box or file/document uploader in Personal AI, you can utilize #hashtags for single words or :colons followed by keywords for multiple words or complete titles. This practice helps in refining the selection of memories for generating answers while ensuring effective organization and retrieval of data. Personal AI is built with a strong emphasis on data privacy and security. It operates under the principle that the data you provide is yours alone. Measures such as encryption, secure data storage, and the optio",
-      image: "https://cdn.prod.website-files.com/5ff65c460ce39f5ec5681c6a/663d12aab1b425e1ad40d3a6_Memory-min.jpg",
-      favicon: "https://cdn.prod.website-files.com/5ff65c460ce39f5ec5681c6a/5ffcbe4a31309a2dcf7d1f18_Human%20AI%20Icon%2032x32-bolder.png"
-    },
-    {
-      id: "https://iki.ai/",
-      title: "IKI AI \u2013 Intelligent Knowledge Interface",
-      url: "https://iki.ai/",
-      publishedDate: "2025-04-10T16:28:59.000Z",
-      author: "",
-      score: 0.38676750659942627,
-      text: "Think faster. Organize deeper. All in one place. An AI-native workspace for\xA0research, strategy, and creative work An AI-native workspace for\xA0research, strategy, and creative work Backed by 500 Global Backed by 500 Global Backed by 500 Global Capture anything. Build your thinking library. Capture anything. Build your thinking library. Capture anything. Build your thinking library. AI assistant Turn long reads into clear insights. IKI summarizes, highlights, and connects the dots. AI assistant Turn long reads into clear insights. IKI summarizes, highlights, and connects the dots. AI assistant Turn long reads into clear insights. IKI summarizes, highlights, and connects the dots. AI editor AI writing with real context. Grounded in your content, not the internet. AI editor AI writing with real context. Grounded in your content, not the internet. AI editor AI writing with real context. Grounded in your content, not the internet. Team spaces Your team\u2019s shared brain. One space for knowledge, context, and decisions. Team spaces Your team\u2019s shared brain. One space for knowledge, context, and decisions. Team spaces Your team\u2019s shared brain. One space for knowledge, context, and decisions. Everything you need for smarter knowledge work AI Editor Ask IKI AI \uF890 Heading 1 B U I \uF107 \uF107 \uF0C1 Browser extension Download extension to save webpages in one click along with notes Author Spotify Design Youtube \xB7 3 min read Designing Data Science Tools at Spotify: Part 2 AI Summury Methods based on the relational path have shown strong, interpretable, and transferable reasoning ability. However, paths are naturally limited in capturing local evidence in graphs...Methods based on the relational path have shown strong, interpretable LLMs powered by top-tier models you trust \uE03E Multi-source insights with agent context AI Digest Everything you need for smarter knowledge work AI Editor Ask IKI AI \uF890 Heading 1 B U I \uF107 \uF107 \uF0C1 Browser extension Download extension to save webpages in one click along with notes Author Spotify Design Youtube \xB7 3 min read Designing Data Science Tools at Spotify: Part 2 AI Summury Methods based on the relational path have shown strong, interpretable, and transferable reasoning ability. However, paths are naturally limited in capturing local evidence in graphs...Methods based on the relational path have shown strong, interpretable LLMs powered by top-tier models you trust \uE03E Multi-source insights with agent context AI Digest Everything you need for smarter knowledge work AI Editor Ask IKI AI \uF890 Heading 1 B U I \uF107 \uF107 \uF0C1 Browser extension Download extension to save webpages in one click along with notes Author Spotify Design Youtube \xB7 3 min read Designing Data Science Tools at Spotify: Part 2 AI Summury Methods based on the relational path have shown strong, interpretable, and transferable reasoning ability. However, paths are naturally limited in capturing local evidence in graphs...Methods based on the relational path have shown strong, interpretable LLMs powered by",
-      image: "https://framerusercontent.com/assets/cI6Uo7x4q0W3uxzOt2preXjv6aE.jpg",
-      favicon: "https://framerusercontent.com/images/5NLFiJq5bLl5FXOTcVQX8vhkU.png"
-    },
-    {
-      id: "https://supermemory.ai/",
-      title: "supermemory\u2122",
-      url: "https://supermemory.ai/",
-      publishedDate: "2025-01-01T00:00:00.000Z",
-      author: "",
-      score: 0.393942266702652,
-      text: `The universal memory API for the AI era Stop building retrieval from scratch. Personalise LLMs for your users. Built for developers who ship. Start building DOCS Context is everything Without it, even the smartest AI is just an expensive chatbot $ init vector_database Way too expensive. Time to switch. Painfully slow. Let's try another. Won't scale. Back to square one. Maintenance nightmare. Need alternatives. $ choose embedding_model Which model fits your use case? Confusing performance tradeoffs Can't keep up with new releases $ handle format_parsing Markdown: Tables break everything HTML: Scripts and styles interfere PDF: Layout ruins extraction Word docs: Unpredictable formatting $ calculate scaling_costs Costs explode at production scale Performance degrades as data grows Engineering hours pile up fast $ setup connection_sync Sync failures between data sources API rate limits during large syncs Images: Need vision models now? Audio/Video: Transcription costs soar $ init multimodal_support Websites: JS &amp; rate limits are messy PDFs: OCR fails, extraction inconsistent Authentication tokens expire constantly $ init vector_database Way too expensive. Time to switch. Painfully slow. Let's try another. Won't scale. Back to square one. Maintenance nightmare. Need alternatives. $ choose embedding_model Which model fits your use case? Confusing performance tradeoffs Can't keep up with new releases $ handle format_parsing Markdown: Tables break everything HTML: Scripts and styles interfere PDF: Layout ruins extraction Word docs: Unpredictable formatting $ calculate scaling_costs Costs explode at production scale Performance degrades as data grows Engineering hours pile up fast $ setup connection_sync Sync failures between data sources API rate limits during large syncs Images: Need vision models now? Audio/Video: Transcription costs soar $ init multimodal_support Websites: JS &amp; rate limits are messy PDFs: OCR fails, extraction inconsistent Authentication tokens expire constantly FEATURES\xA0\xA0\u2022\xA0\xA0FEATURES\xA0\xA0\u2022 \xA0FEATURES Unlock the Full Potential of Your Data const response = await fetch( 'https://api.supermemory.ai/v3/memories', {
- method: 'POST',
- headers: {
- 'Authorization': 'Bearer sm_ywdhjSbiDLkLIjjVotSegR_rsq3ZZKNRJmVr12p4ItTcf' 
- },
- body: JSON.stringify({
- content: 'My name is Shreyans.',
- // or https://example.com 
- // or https://example.com/page.pdf 
- metadata: {
- user_id: '123' 
- }
- }),
-})
- const data = await response.json() const response = await fetch( 'https://api.supermemory.ai/v3/memories', {
- method: 'GET',
- headers: {
- 'Authorization': 'Bearer sm_ywdhjSbiDLkLIjjVotSegR_rsq3ZZKNRJmVr12p4ItTcf',
- },
- body: JSON.stringify({
- q: "What's my name?" 
- })
-})
- const data = await response.json() const response = await fetch( 'https://api.supermemory.ai/v3/connections/onedrive', {
- method: 'POST',
- headers: {
- 'Authorization': 'Bearer sm_ywdhjSbiDLkLIjjVotSegR_rsq3ZZKNRJmVr12p4ItTcf',
- }
-});
- const data = await response.json(); solution\xA0 \u2022 \xA0sol`,
-      image: "https://cdn.prod.website-files.com/6826235ef861ed9464b064c8/6826251d65991babe21a9a9a_Frame%2031.png",
-      favicon: "https://cdn.prod.website-files.com/6826235ef861ed9464b064c8/682639813def380d7694f590_favicon.png"
-    },
-    {
-      id: "https://mykin.ai/",
-      title: "Kin - Private, and Emotionally Intelligent, Personal AI",
-      url: "https://mykin.ai/",
-      publishedDate: "2025-05-26T00:00:00.000Z",
-      author: "",
-      score: 0.38142070174217224,
-      text: "Clarity and confidence. Always on hand. Kin is a new kind of personal AI companion, more emotionally intelligent and private than ever. For whatever life throws at you. Available on iPhone and Android Anytime. Anywhere. Life at work is becoming increasingly challenging to navigate Think with Kin Personalized coaching can be inaccessible and expensive Talk with Kin How can Kin help? Inspiration \u201CWhenever I need fresh ideas or just a soundboard, I know I can quickly turn to Kin.\u201D Inspiration \u201CWhenever I need fresh ideas or just a soundboard, I know I can quickly turn to Kin.\u201D Planning \u201CI use Kin to think things through, set goals, and organize my time.\u201D Planning \u201CI use Kin to think things through, set goals, and organize my time.\u201D Learning \u201CI can learn about almost any topic, with structured lessons created in seconds.\u201D Learning \u201CI can learn about almost any topic, with structured lessons created in seconds.\u201D Support \u201CKin helps me with everything from small tasks to processing ideas and emotions.\u201D Support \u201CKin helps me with everything from small tasks to processing ideas and emotions.\u201D Guidance \u201CI\u2019m more aware of my strengths and I feel better prepared for tricky conversations.\u201D Guidance \u201CI\u2019m more aware of my strengths and I feel better prepared for tricky conversations.\u201D Kin remembers, so you don\u2019t have to. The more you interact with Kin, the more Kin learns about you and your life. Because Kin understands both the big picture and its complexities, it can provide genuinely meaningful support in your day-to-day. Learn more Private &amp; Secure Kin encrypts and stores your data securely on you device. No one else can see or access it. Powerful features. Scandinavian design. Smart journaling Share your thoughts and notes to reflect and build a better Kin. Coming soon Powered by open source models Coming soon Semantic and Episodic memory Coming soon Private, encrypted local-first storage Coming soon Intelligent reminders Stay on top of what matters with timely reminders. Coming soon Conversational voice chat Coming soon Third party integration Connect your Kin to the apps you love like Google calendar. Coming soon Proudly made in Copenhagen, Denmark Get started with simple tutorials and big ideas Frequently asked questions Product How does Kin's memory work? Kin\u2019s memory pulls information from your messages into a database on your device so it can always reference it. Kin\u2019s memory is automatic, so in practice, it works just by you talking with Kin. General More than anyone else. Every word you share and every reply is stored locally on your device - unless you change your settings to allow otherwise. You have full control over deleting it at any time. General Do I need a subscription to use Kin? No - Kin is currently free and without message limits for our beta users. However, we\u2019re expecting to transition to a subscription model once we hit full release - we\u2019ll make sure to talk a lot about that before it happens, though. Product Can I use Kin on a d",
-      image: "https://cdn.prod.website-files.com/67b8fb50931278cabb866969/67d2a6c56ee313becd0f482d_img-opengraph.jpg",
-      favicon: "https://cdn.prod.website-files.com/67b8fb50931278cabb866969/67c0cfc2c45ca5db9ca5c9e4_favicon.png"
-    },
-    {
-      id: "https://try.rememberizer.ai/blog/introducing-rememberizer-connect-knowledge-to-your-ai",
-      title: "Introducing Rememberizer - Connect Knowledge To Your AI",
-      url: "https://try.rememberizer.ai/blog/introducing-rememberizer-connect-knowledge-to-your-ai",
-      publishedDate: "2024-01-28T00:00:00.000Z",
-      author: "",
-      score: 0.38043755292892456,
-      text: "Introduction In the rapidly evolving world of artificial intelligence (AI), Rememberizer emerges as a revolutionary platform that profoundly changes how both developers and personal consumers interact with AI, especially Generative Pre-trained Transformers (GPT). This platform is not just another tool; it's a transformative solution, making AI interactions deeply personal, intuitive, and efficient. Let\u2019s dive into how Rememberizer is redefining AI personalization and integration, offering unique experiences for a diverse range of users, free. \u200D Part 1: Rememberizer for Personal Consumers \u200D Why Rememberizer Matters for Personal Users Generative AI apps work better when they have access to background information. They need to know what you know. A great way to achieve that is to give them access to relevant content from the documents, data and discussions you create and use. This is what Rememberizer does. Rememberizer helps by seamlessly integrating personal data with AI applications. For OpenAI GPTs users, this means transforming your interactions with AI into something deeply personal and relevant. By indexing your data just once, Rememberizer avoids wasting time performing the same process over and over again. \u200D Empowering Personal AI Experiences Whether you\u2019re engaging in creative projects, professional tasks, or simply exploring AI for personal curiosity, Rememberizer brings a unique value proposition. It transforms your data into a powerful AI collaborator, ensuring your interactions are tailored to your specific circumstances. Imagine an AI that feels intuitively designed for you, understanding your projects, circumstances and recent discussions. That\u2019s the personalized AI experience Rememberizer delivers. Part 2: Rememberizer for Developers Revolutionizing AI Integration in App Development For developers, Rememberizer is a game-changer. It simplifies the integration of user data into AI applications, enhancing app functionality and user experience. Rememberizer connects directly to various data sources including Slack and Google Drive, embedding their contents semantic meaning into a vector database. This process not only elevates the AI capabilities of your app but also saves vast amounts GPU processing costs and engineering resources in backend development: it\u2019s free! The Developer's Advantage with Rememberizer Streamlined Data Integration: Rememberizer takes care of the complex process of integrating data sources into a vector database, allowing developers to focus more on creative aspects of app development. Enhanced AI Capabilities: By leveraging Rememberizer, apps gain access to rich, personalized data, leading to more intuitive and context-aware AI interactions. Personalization and Continuous Adaptation: Apps powered by Rememberizer can offer unparalleled personalization, learning, and adapting based on the user's data, thereby improving over time. Part 3: Pricing and Accessibility for All Rememberizer is committed to democratizing ",
-      image: "https://cdn.prod.website-files.com/656fc35f7b92e991c863ce0a/65b7523200497f3ac6391238_Rememberizer%20banner.png",
-      favicon: "https://cdn.prod.website-files.com/656fc35f7b92e991c863cdc4/657acdfb9a0ba55d8f622765_Favicon.png"
-    },
-    {
-      id: "https://twinmind.com/",
-      title: "TwinMind",
-      url: "https://twinmind.com/",
-      publishedDate: "2025-05-23T09:12:49.000Z",
-      author: "",
-      score: 0.38130462169647217,
-      text: "\n Never Forget Anything with Your Never Forget Anything with Your Never Forget Anything with Your Second Brain Memory Vault Life Copilot AI Notetaker Second Brain Second Brain Memory Vault Life Copilot AI Notetaker Second Brain Second Brain Memory Vault Life Copilot AI Notetaker Second Brain Get perfect notes, to-dos, and proactive answers during meetings, lectures, interviews, and conversations. Get perfect notes, to-dos, and proactive answers during meetings, lectures, interviews, and conversations. Watch Demo Watch Demo Watch Demo Featured in Featured in Trusted by users at Trusted by users at Capture any moment, even inside your pocket Capture any moment, even inside your pocket Transcribe everything. Forget nothing. Ask anything. Transcribe everything. Forget nothing. Ask anything. Transcribe everything. Forget nothing. Ask anything. Seamlessly switch from mobile to desktop Seamlessly switch from mobile to desktop With TwinMind for Chrome, transcribe video calls or chat with tabs,\xA0PDFs, Youtube\xA0videos, and automate your work. With the TwinMind Chrome sidebar, transcribe video calls or chat with websites,\xA0PDFs, Youtube\xA0videos, and all your memories. Works with all the products you love Works with all the products you love Ask anything with context from all your favorite websites and insert answers directly into them on Chrome. Ask anything with context from all your favorite websites and insert answers directly into them on Chrome. Transcribe video calls or capture context from all your favorite websites, and insert answers into them on Chrome browser. Get Proactive Answers Get Proactive Answers Get personalized suggestions, prepare for meetings or exams based on all your notes synced with your calendar. Get personalized suggestions, prepare for meetings or exams based on all your notes synced with your calendar. Unlock Perfect Memory Unlock Perfect Memory Your brain forgets 90% of memories in 7 days but TwinMind doesn\u2019t. Ask TwinMind anything with Deep Memory Search. Your brain forgets 90% of memories in 7 days but TwinMind doesn\u2019t. Ask TwinMind anything with Deep Memory Search. Summarize all my meetings Ask TwinMind Summarize all my meetings Ask TwinMind Summarize all my meetings Ask TwinMind Insert Insert Insert Automate Your Work Automate Your Work Generate follow-up emails, reports, assignments based on memories. Insert anywhere on your browser in one click. Generate follow-up emails, reports, assignments based on memories. Insert anywhere on your browser in one click. 100% privacy with offline mode 100% privacy with offline mode 100% privacy with offline mode Transcribes without recording TwinMind processes your audio on-the-fly in real-time and saves only the transcripts on-device, ensuring that your audio is never stored anywhere. Transcribes without recording TwinMind processes your audio on-the-fly in real-time and saves only the transcripts on-device, ensuring that your audio is never stored anywhere. Transcribes without recording ",
-      image: "https://framerusercontent.com/assets/9u5tx2lerz0ndBVcB14sg4tNoKs.png",
-      favicon: "https://framerusercontent.com/images/zDX0zsHZ6Z2PvwK2vmkOsISWBiY.svg"
-    }
-  ],
-  costDollars: {
-    total: 0.015,
-    search: {
-      neural: 5e-3
-    },
-    contents: {
-      text: 0.01
-    }
-  }
-};
-
-// src/functions/exa/data/exa-search-1748337331526.ts
-var exa_search_1748337331526_default = {
-  requestId: "0dc12e344fa649884456960ca1a54954",
-  autopromptString: "PKM software artificial intelligence integration open source projects",
-  resolvedSearchType: "neural",
-  results: [
-    {
-      id: "https://github.com/subspace-ai/subspace",
-      title: "GitHub - subspace-ai/subspace: PKM + REPL + AI",
-      url: "https://github.com/subspace-ai/subspace",
-      publishedDate: "2023-03-23T16:02:40.000Z",
-      author: "subspace-ai",
-      score: 0.7530648708343506,
-      text: "subspace.ai - PKM + REPL + AI \n The long-term goal of subspace is to be/have three things: \n \n PKM (Personal Knowledge Management system) like Roam Research or Tana. \n REPL-like (Read Evaluate Print Loop) capabilities. Should be able to execute individual code cells in the JVM backend and rendered in the frontend with Electric. Similar behaviour can be achieved with other languages via Jupyter kernels (or GraalVM Polyglot) and JavaScript. \n AI (Artificial Intelligence) integrations. Should be integrated with LLMs - e.g. write GPT queries in subspace, and incorporate the response to your personal knowledge base as a new node. Intelligent search and LLM-based summaries and reasoning over the existing knowledge base (Retrieval Oriented Generation, RAG). \n \n The overall design should be open-ended, allowing for easy forking and providing custom node types / rendering functions. The goal is not to be just a storage of information, but a control panel for commonly used workflows. So that you can create convenient shortcuts and informative output views with Clojure + Electric. Since you persist which actions you took over time, you can search for past outputs and interleave these with your personal notes. Later query your knowledge base with RAG in natural language, or query it with GPT by exposing subspace knowledge base as an API to GPT. \n For example, additional customizations and use cases could be: \n \n Intelligent work log for day to day coding. \n Wrappers for any babashka / shell scripts you already have. \n Wrapper functions to MLOps platform (or some other task manager) to trigger jobs, query stats and logs from past train runs. Build dashboards as subspace nodes from the result of such queries with Electric+HTML. \n Wrappers for common Kubernetes / AWS / GCP commands. Build ad hoc UIs on top of your cluster that make sense to you. \n Wrappers that pull the contents of arxiv documents as subspace nodes. \n Spaced repetition learning of content (of nodes which you mark to be remembered). \n \n UI/UX \n There will be two types of UI elements: pages and nodes. Pages contain nodes, and nodes can nest other nodes. Both pages and nodes are referencable (meaning you can link to them and the page/node will get a backreference). \n Each node contains some media, and possibly subnodes. \n Media can be: \n \n Text, numeric, Markdown \n Image, video, audio \n Flexible spreadsheet tesserrae \n code block, which can be executed in a jupyter kernel (runs once) \n code block containing an e/fn (runs continuously when on the page) \n \n Executing an e/fn is the most powerful and flexible thing to do. It can pull data in from other nodes on the page or in the graph, and displays its own little UI within its boundaries. Crucially, when upstream info changes, your e/fn's output gets recomputed. Running tesserrae is also very powerful; you can think of subspace as a non-grid tesserae that can also embed tesserae. \n Subnodes can be organised either by indenting or tiling. \n \n Indente",
-      image: "https://opengraph.githubassets.com/734547dbba15cefe41b9ad9cd97ba2ac489aeebd18945d54dbf7b1931b5ed980/subspace-ai/subspace",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/khoj-ai/khoj",
-      title: "GitHub - khoj-ai/khoj: Your AI second brain. Self-hostable. Get answers from the web or your docs. Build custom agents, schedule automations, do deep research. Turn any online or local LLM into your personal, autonomous AI (gpt, claude, gemini, llama, qwen, mistral). Get started - free.",
-      url: "https://github.com/khoj-ai/khoj",
-      publishedDate: "2021-08-16T01:48:44.000Z",
-      author: "khoj-ai",
-      score: 0.33666935563087463,
-      text: "\n \n \n \n \n Your AI second brain \n \n \n \n \u{1F381} New \n \n Start any message with /research to try out the experimental research mode with Khoj. \n Anyone can now create custom agents with tunable personality, tools and knowledge bases. \n Read about Khoj's excellent performance on modern retrieval and reasoning benchmarks. \n \n \n Overview \n Khoj is a personal AI app to extend your capabilities. It smoothly scales up from an on-device personal AI to a cloud-scale enterprise AI. \n \n Chat with any local or online LLM (e.g llama3, qwen, gemma, mistral, gpt, claude, gemini, deepseek). \n Get answers from the internet and your docs (including image, pdf, markdown, org-mode, word, notion files). \n Access it from your Browser, Obsidian, Emacs, Desktop, Phone or Whatsapp. \n Create agents with custom knowledge, persona, chat model and tools to take on any role. \n Automate away repetitive research. Get personal newsletters and smart notifications delivered to your inbox. \n Find relevant docs quickly and easily using our advanced semantic search. \n Generate images, talk out loud, play your messages. \n Khoj is open-source, self-hostable. Always. \n Run it privately on your computer or try it on our cloud app. \n \n \n See it in action \n \n Go to https://app.khoj.dev to see Khoj live. \n Full feature list \n You can see the full feature list here. \n Self-Host \n To get started with self-hosting Khoj, read the docs. \n Enterprise \n Khoj is available as a cloud service, on-premises, or as a hybrid solution. To learn more about Khoj Enterprise, visit our website. \n Frequently Asked Questions (FAQ) \n Q: Can I use Khoj without self-hosting? \n Yes! You can use Khoj right away at https://app.khoj.dev \u2014 no setup required. \n Q: What kinds of documents can Khoj read? \n Khoj supports a wide variety: PDFs, Markdown, Notion, Word docs, org-mode files, and more. \n Q: How can I make my own agent? \n Check out this blog post for a step-by-step guide to custom agents.\nFor more questions, head over to our Discord! \n Contributors \n Cheers to our awesome contributors! \u{1F389} \n \n \n Made with contrib.rocks. \n Interested in Contributing? \n Khoj is open source. It is sustained by the community and we\u2019d love for you to join it! Whether you\u2019re a coder, designer, writer, or enthusiast, there\u2019s a place for you. \n Why Contribute? \n \n Make an Impact: Help build, test and improve a tool used by thousands to boost productivity. \n Learn &amp; Grow: Work on cutting-edge AI, LLMs, and semantic search technologies. \n \n You can help us build new features, improve the project documentation, report issues and fix bugs. If you're a developer, please see our Contributing Guidelines and check out good first issues to work on. \n",
-      image: "https://repository-images.githubusercontent.com/396569538/533a8bf7-385f-427b-a03f-76795fd938ed",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/paulbricman/conceptarium",
-      title: "GitHub - paulbricman/conceptarium: A fluid medium for storing, relating, and surfacing thoughts.",
-      url: "https://github.com/paulbricman/conceptarium",
-      publishedDate: "2021-08-12T04:45:29.000Z",
-      author: "paulbricman",
-      score: 0.3376504182815552,
-      text: "\n \u{1F4A1} Conceptarium \n The conceptarium is an experimental personal knowledge base designed to weave AI capabilities into knowledge work. Its main features include: \n \n powerful multi-modal search across ideas \n sharing microverses of knowledge with peers \n ranking items by Anki-like activation, so as to promote serendipity \n \n Installation \n Docker \n After installing docker and docker-compose, run: \n # install with:\ncurl -fsS https://raw.githubusercontent.com/paulbricman/conceptarium/main/docker-compose.yml -o docker-compose.yml\nmkdir knowledge\ndocker-compose up -d\n# stop with:\ndocker-compose stop\n# update with:\ndocker-compose stop\ndocker-compose rm -f\ndocker-compose pull\ndocker-compose up -d\n \n Note that you'll have to wait a bit initially for the models to be downloaded in the docker container. Use docker logs &lt;backend container ID&gt; or watch the process's memory for feedback on that. Or just try using it until it via the API or UI until it works (see usage). \n Source \n After pulling this repo run: \n python3 -m pip install -r frontend/requirements.txt\npython3 -m pip install -r backend/requirements.txt\nstreamlit run frontend/main.py\n# in a separate session:\ncd backend\npython3 -m uvicorn main:app --reload\n# update by pulling from repo again\n \n Missing dependencies? Please have a look at frontend/Dockerfile and backend/Dockerfile. ARM architecture (e.g. Raspberry Pi)? Remove the torch entries from requirements.txt, and install a custom-built version. \n Usage \n The web app should then be available at localhost:8501, while the API at localhost:8000 (with docs at localhost:8000/docs). The backend component takes a few minutes to get the ML models at first. \n To access your local instance, enter the conceptarium URL (i.e. localhost:8000 if you ran from source, backend.docker:8000 if you used docker), and your desired token. Remember your token, as you'll have to use it to authenticate in future sessions. \n",
-      image: "https://opengraph.githubassets.com/2b454d3e4b9d69c65d465d8ec6609b3b61f34b83f1f8eece471806be32e710bc/paulbricman/conceptarium",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/mfakih/Pomegranate-PKM",
-      title: "GitHub - mfakih/Pomegranate-PKM: Pomegranate PKM is a new open source web-based cross-platform work and knowledge management application for productive and prolific people. PKM features text-based commands for adding, updating and searching records, thus providing powerful tools to manage information. It also allows the user to build up the navigation menu using saved searches.",
-      url: "https://github.com/mfakih/Pomegranate-PKM",
-      publishedDate: "2014-03-17T06:28:12.000Z",
-      author: "mfakih",
-      score: 0.7761150002479553,
-      text: "Pomegranate-PKM \n Pomegranate PKM is a new open source web-based cross-platform work and knowledge management application for productive and prolific people. \n PKM features text-based commands for adding, updating and searching records, thus providing powerful tools to manage information. It also allows the user to build up the navigation menu using saved searches. \n \n Pomegranate PKM manages: \n \n Goals, tasks, and plans \n Journal and indicators \n Writings and notes \n Resources (books, articles, news, presentations, audiobooks, documentaries, movies etc),and book excerpts, mainly book chapters. \n Documents e.g. Word documents, Excels \n People \n \n In technical terms, Pomegranate PKM is a combination of: \n \n Document management system \n Content management system \n Research index cards and reference management \n Bug tracking systems, applied for the software development and self development \n Lightweight project management \n Powerful task management \n Time tracking \n Blog (e.g. WordPress) client \n \n My in-progress book at LeanPub outlines the motivations, design principles and the features of Pomegranate PKM. \n",
-      image: "https://opengraph.githubassets.com/d4afbe16f55b89cbdd3344472df483147de49f6a8a136bd1da7af7e568c16908/mfakih/Pomegranate-PKM",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/mfakih294/Nibras-PKM",
-      title: "GitHub - mfakih294/Nibras-PKM: A web-based self-hosted open-source system for the long-term management of personal information. It targets the needs of advanced users with serious information management needs. It is accompanied with an Android application that syncs the bookmarked records over local Wifi network.",
-      url: "https://github.com/mfakih294/Nibras-PKM",
-      publishedDate: "2019-09-14T02:05:28.000Z",
-      author: "mfakih294",
-      score: 0.7633954882621765,
-      text: "Nibras PKM \n Nibras PKM is a web-based self-hosted open source system for\nthe long-term management of personal information.\nIt is a combination of a web-based application\nintended for desktop use and where all the records are entered,\nand an Android mobile reader application. \n \n Local \n The user has full control over his/her data, without the need for a (fast) internet connection, and without all the distractions and information overload that the internet can cause. \n Open source \n The user has control over the system itself too, especially when using it on the long term to manage the important personal information and files. \n Comprehensize \n It manages resources (articles, books, documents), notes, writings, tasks, goals, journal, planner, payments, indicators, and (study) courses and departments. \n Powerful \n It was designed with large amounts of information in mind. In current usage, it manages dozens of thousands of records. With its commands and saved searches, it makes easy to navigate through all the information. \n Main Features \n \n Flexible text-based commands to add, update and search records, which provides powerful ways to manage information. \n Saved searches to save searches for later use. \n Ability to display records on calendars and Kanban boards. \n Full-text search of all record fields. \n Simple file system integration so to greatly reduce the need to organize files manually. \n \n Documentation \n User's guide is available online at https://mfakih294.github.io/Nibras-PKM/. \n Releases \n Nibras PKM is hosted on GitHub https://github.com/mfakih294/Nibras-PKM. \n Quick start guide \n Running Nibras requires three simple steps: \n \n Download the bundle file corresponding to your platform, e.g. nibras-bundle-windows.zip from the releases page on Github. \n Extract the zipped file to a location of your choice on your local disk. \n Launch Nibras by double clicking on ./scripts/start file. \n \n Once Nibras has finished launching, a message like the one below will appear. \n * Nibras has launched. You can access it from: * \n * https://localhost:1441/ * \n Go to https://localhost:1441/ using Firefox or Chrome. On the login page, enter nibras for username and nibras for the password. \n Notes: \n \n As it has a self-signed certificate, you need to accept and bypass the security warning that shows up at the beginning. \n On Linux, you need to make the files inside ./scripts and ./tomcat/bin folders executable (chmod +x *). \n To stop Nibras, you can close this window, or press ctrl+c in it, or run ./scripts/stop script. \n \n Technical details \n \n Nibras is developed in Grails framework 3.3.10, a dynamic framework on top of the Java platform. \n Grails applications run on any platform that can run Java 8 and later, so practically all platforms, including Windows, Linux, Mac. \n For production use, Nibras uses MySQL 5+ for its database, and the file system to store the files of the records. To testing and demonstration, it can run with h2 database, with zero ex",
-      image: "https://opengraph.githubassets.com/5e45c614cd8441100a4acd0e48d8b9c15984b51e816d4d4683436dd3be25c813/mfakih294/Nibras-PKM",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/reorproject/reor",
-      title: "GitHub - reorproject/reor: Private & local AI personal knowledge management app for high entropy people.",
-      url: "https://github.com/reorproject/reor",
-      publishedDate: "2023-11-27T01:30:44.000Z",
-      author: "reorproject",
-      text: `Reor Project 
- 
-Private &amp; local AI personal knowledge management app. 
- 
- 
- 
- 
- 
- 
- \u{1F4E2} Announcement 
- We are now on Discord! Our team is shipping very quickly right now so sharing \u2764\uFE0Ffeedback\u2764\uFE0F with us will really help shape the product \u{1F680} 
- 
- About 
- Reor is an AI-powered desktop note-taking app: it automatically links related notes, answers questions on your notes and provides semantic search. Everything is stored locally and you can edit your notes with an Obsidian-like markdown editor. 
- The hypothesis of the project is that AI tools for thought should run models locally by default. Reor stands on the shoulders of the giants Ollama, Transformers.js &amp; LanceDB to enable both LLMs and embedding models to run locally: 
- 
- Every note you write is chunked and embedded into an internal vector database. 
- Related notes are connected automatically via vector similarity. 
- LLM-powered Q&amp;A does RAG on your corpus of notes. 
- Everything can be searched semantically. 
- 
- One way to think about Reor is as a RAG app with two generators: the LLM and the human. In Q&amp;A mode, the LLM is fed retrieved context from the corpus to help answer a query. Similarly, in editor mode, the human can toggle the sidebar to reveal related notes "retrieved" from the corpus. This is quite a powerful way of "augmenting" your thoughts by cross-referencing ideas in a current note against related ideas from your corpus. 
- Getting Started 
- 
- Download from reorproject.org or releases. Mac, Linux &amp; Windows are all supported. 
- Install like a normal App. 
- 
- Running local models 
- Reor interacts directly with Ollama which means you can download and run models locally right from inside Reor. Head to Settings-&gt;Add New Local LLM then enter the name of the model you want Reor to download. You can find available models here. 
- You can also connect to an OpenAI-compatible API like Oobabooga, Ollama or OpenAI itself! 
- Importing notes from other apps 
- Reor works within a single directory in the filesystem. You choose the directory on first boot.
-To import notes/files from another app, you'll need to populate that directory manually with markdown files. Note that if you have frontmatter in your markdown files it may not parse correctly. Integrations with other apps are hopefully coming soon! 
- Building from source 
- Make sure you have nodejs installed. 
- Clone repo 
- git clone https://github.com/reorproject/reor.git
- 
- Install dependencies 
- Run for dev 
- Build 
- Interested in contributing? 
- We are always on the lookout for contributors keen on building the future of knowledge management. Have a feature idea? Want to squash a bug? Want to improve some styling? We'd love to hear it. Check out our issues page and the contributing guide to get started. 
- License 
- AGPL-3.0 license. See LICENSE for details. 
- Reor means "to think" in Latin. 
-`,
-      image: "https://opengraph.githubassets.com/101249afc41e6b8729eca3c619d4c08c5c67288ab4126de16c59c1ab97c5492c/reorproject/reor",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/memex-life/memex",
-      title: "GitHub - memex-life/memex: Your second brain for the web browsing. An AI powered Chrome extension that constructs personal knowledge base for you.",
-      url: "https://github.com/memex-life/memex",
-      publishedDate: "2023-03-16T23:48:35.000Z",
-      author: "memex-life",
-      score: 0.34730345010757446,
-      text: "Memex \n Your second brain for web browsing. Picture possessing the ultimate ability of total recall. \n \n Overview \n This project aims to create a browser extension that acts like a personal memex machine.\nIt will keep track of everything you browse online to build your own knowledge base.\nThen it will use AI to retrieve that knowledge whenever you need it. \n What is a Memex? \n \n Consider a future device for individual use, which is a sort of mechanized private file and library. It needs a name, and, to coin one at random, \u201Cmemex\u201D will do. A memex is a device in which an individual stores all his books, records, and communications, and which is mechanized so that it may be consulted with exceeding speed and flexibility. It is an enlarged intimate supplement to his memory. \n--- \u201CAs We May Think\u201D Vannevar Bush (1945) \n \n Features \n \n Seamlessly captures content and metadata from your web browsing. \n Constructs your own personalized knowledge base on your local device \n Retrive knowledge with power of AI. \n \n How it works \n When you browse the web, this extension will inject a script to capture the text content on the pages you visit. It will send that content to the backend service-worker for processing\nThe service-worker will break the content into pieces and store it in a database.\nThe popup page acts as a chat interface to answer your questions using the information in the database. \n Getting Started \n Build &amp; import Extension \n Build extension files into dist/ folder \n npm install\nnpm run build # or npm run watch \n Load extension \n Start the Kownledge Base server \n Currently the LangchainJs has not yet support browser runtime. The extension still needs a backend server as Knowledge Base implementaion. \n set environments: \n export TOKENIZERS_PARALLELISM=false\nexport OPENAI_API_KEY=&lt;your-api-key&gt;\ncd server\nFLASK_APP=server flask run\n \n Start using \n Once you have completed the above steps, you can start using the Memex browser extension to enhance your web browsing experience. \n \n As you browse the web, the extension will automatically capture and store the text content from the web pages you visit, along with their metadata, in your personalized knowledge base. \n When you need to retrieve information or recall something from your browsing history, simply open the chat interface by clicking on the Memex extension icon. Type your question or query into the chat interface and press Enter or click the Send button. The Memex extension will use AI to search your knowledge base and provide you with the most relevant information based on your query. \n \n",
-      image: "https://opengraph.githubassets.com/aa7966b46e8bb10410af6cdb5af62c9095d99c4b9d17683b246641b8a1291746/memex-life/memex",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/samkeen/knowling",
-      title: "GitHub - samkeen/knowling: A desktop notes application leveraging AI designed for Personal Knowledge Management (PKM)",
-      url: "https://github.com/samkeen/knowling",
-      publishedDate: "2024-03-08T03:28:38.000Z",
-      author: "samkeen",
-      score: 0.8010122776031494,
-      text: `Knowling 
- A desktop notes application designed for Personal Knowledge Management (PKM) 
- 
- Knowling aims to provide users with an intuitive platform for gathering and organizing knowledge from various research
-sources. By leveraging AI, Knowling assists users in categorizing their notes and highlighting connections between them,
-thereby enhancing the overall management of their personal knowledge store. 
- Features 
- 
- Fast Performance: Knowling is developed using Rust and JavaScript, ensuring a responsive and efficient user
-experience. 
- WSIWIG Markdown Editor: A What-You-See-Is-What-You-Get (WSIWIG) Markdown editor for seamless and straightforward
-note-taking. 
- Simple, Uncluttered UI: The user interface is designed to be minimalistic and distraction-free, allowing users to
-focus on their content. 
- Export/Import Notes: Easily export and import notes to manage your knowledge base across different devices and
-formats. 
- AI Integration: AI is integrated to empower users by automatically categorizing notes and identifying meaningful
-connections between them. 
- Open Source: Knowling is open source and licensed under the Apache 2.0 license, encouraging community
-contributions
-and
-transparency. 
- 
- Current Development Status 
- Knowling is currently in the early stages of development, with a minimal feature set. We are actively working on
-expanding the application's capabilities and enhancing its functionality. We welcome you to check out the open feature
-requests and encourage you to open new ones if you have any suggestions or ideas. 
- 
- Open Issues 
- Project view 
- 
- We hope you find Knowling valuable for managing your personal knowledge. If you have any feedback or encounter any
-issues, please don't hesitate to reach out or contribute to the project. 
- Why the name Knowling: Knowling is a play on the words "Knowledge" and "Knolling", a process of arranging objects to
-create clean and organized
-spaces. This reflects our goal of helping users keep their knowledge organized and easily accessible. 
- 
- 
- Developing Knowling 
- Knowling is built atop Tauri 1.x 
- Project setup 
- npm install
-npm run tauri dev
- 
- Development 
- Build 
- https://tauri.app/v1/api/cli/ 
- Development follows the common practices of developing a Tauri application. 
- Debugging in RustRover 
- https://tauri.app/v1/guides/debugging/rustrover/ 
-`,
-      image: "https://opengraph.githubassets.com/68a818dd653e6084907d244111f983fe2b2367dcfb8eed93ebece179892ae74c/samkeen/knowling",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/whl1207/Knowledge",
-      title: "GitHub - whl1207/Knowledge: Distributed Multi-View Intelligent Knowledge Management Platform",
-      url: "https://github.com/whl1207/Knowledge",
-      publishedDate: "2023-08-26T03:26:41.000Z",
-      author: "whl1207",
-      score: 0.35489749908447266,
-      text: "AI-KM Intelligent Knowledge Management Platform \n Overview \n AI-KM (Artificial Intelligence Knowledge Management) is a next-generation knowledge management platform that integrates cutting-edge AI technologies. Leveraging large language models and knowledge graph technologies, it helps individuals and organizations achieve efficient knowledge organization, in-depth analysis, and intelligent application. \n \n Core Value \n \n Intelligent Knowledge Processing: Automatically parses, queries, and associates knowledge content \n Multi-dimensional Visualization: Provides 6 view modes to present knowledge relationships \n Open Model Integration: Supports seamless switching between mainstream open-source large language models via Ollama \n Enterprise-grade Security: All data processing is performed locally \n \n Key Features \n 1. Core Technical Architecture \n \n \n Multi-model Integration Engine \n \n Supports mainstream large language models deployed via the Ollama framework \n Base models: Deepseek-R1, qwen3, LLaMA3.3, QWQ \n Embedding models: nomic-embed-text, bge-m3, mxbai-embed-large \n Multimodal models: Gemma3, Mistral-Small 3.1 \n \n \n \n Enhanced Retrieval System \n \n RAG (Retrieval-Augmented Generation) architecture \n Supports knowledge base preprocessing (default segmentation by 2 line breaks) \n Supports similarity calculations for various embedding models \n Supports hidden information inference in knowledge bases (default: deducing potential user queries) and knowledge fragment keyword editing \n Supports custom retrieval thresholds (can set knowledge base retrieval thresholds based on cosine similarity, quantity, characters, etc.) \n Explainable analysis and debugging of retrieval results, displaying similarity information for each knowledge fragment \n Supports cosine similarity calculation and MDS dimensionality reduction-based similarity calculation \n \n \n \n Visual Workflow Engine \n \n Drag-and-drop AI processing pipeline construction \n Includes 3+ pre-built node templates \n Supports workflow import/export \n \n \n \n Markdown Document Editing \n \n Deep Markdown parsing and editing \n Document structure analysis (heading hierarchy recognition) \n Code block processing \n \n \n \n Multi-view Knowledge Display Module \n \n \n \n Multi-platform Packaging &amp; Deployment \n \n Electron-based packaging for Windows, Linux, macOS, and other platform clients \n \n \n \n Installation &amp; Deployment \n System Requirements \n \n OS: Windows 10+/macOS 12+/Linux (Ubuntu 20.04+) \n Hardware:\n \n Minimum: 8GB RAM, 4-core CPU, 10GB storage \n Recommended: 16GB+ RAM, dedicated GPU, 50GB+ storage \n \n \n \n Development Environment Setup \n # Install dependencies \nnpm install\n # Run in development mode \nnpm run dev\n # Build Windows client \nnpm run build\n # Generate installation package \n AI-KM \u667A\u80FD\u77E5\u8BC6\u7BA1\u7406\u5E73\u53F0 \n \u6982\u8FF0 \n AI-KM\uFF08Artificial Intelligence Knowledge Management\uFF09\u662F\u4E00\u4E2A\u96C6\u6210\u4E86\u524D\u6CBFAI\u6280\u672F\u7684\u4E0B\u4E00\u4EE3\u77E5\u8BC6\u7BA1\u7406\u5E73\u53F0\uFF0C\u901A\u8FC7\u5927\u8BED\u8A00\u6A21\u578B\u548C\u77E5\u8BC6\u56FE\u8C31\u6280\u672F\uFF0C\u5E2E\u52A9\u4E2A\u4EBA\u548C\u7EC4\u7EC7\u5B9E\u73B0\u77E5\u8BC6\u7684\u9AD8\u6548\u7EC4\u7EC7\u3001\u6DF1\u5EA6\u5206\u6790\u548C\u667A\u80FD\u5E94\u7528\u3002 \n \u6838\u5FC3\u4EF7\u503C \n \n \u667A\u80FD\u77E5\u8BC6\u5904\u7406 \uFF1A\u81EA\u52A8\u89E3\u6790\u3001\u67E5\u8BE2\u548C\u5173\u8054\u77E5\u8BC6\u5185\u5BB9 \n \u591A\u7EF4\u5EA6\u53EF\u89C6\u5316 \uFF1A\u63D0\u4F9B6\u79CD\u89C6\u56FE\u6A21\u5F0F\u5448\u73B0\u77E5\u8BC6\u5173\u7CFB \n \u5F00\u653E\u6A21\u578B\u96C6\u6210 \uFF1A\u53EF\u4EE5\u901A\u8FC7ollama\u652F\u6301\u4E3B\u6D41\u5F00\u6E90",
-      image: "https://opengraph.githubassets.com/fc9354a52086145d1cf60e2b9c3d386a3be8fa44e2e00cbb13cd2b1af09973b7/whl1207/Knowledge",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/putaodoudou/kmagent",
-      title: "GitHub - putaodoudou/kmagent: KMAgent (Knowledge Management Agent)\uFF0C\u57FA\u4E8E\u8BED\u4E49\u5143\u7684\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406GTD\u5DE5\u5177\uFF0C\u4E2A\u4EBA\u667A\u80FD\u52A9\u7406\u3002",
-      url: "https://github.com/putaodoudou/kmagent",
-      publishedDate: "2018-06-05T09:11:21.000Z",
-      author: "putaodoudou",
-      score: 0.35521113872528076,
-      text: "KMAgent-\u4E2A\u4EBA\u667A\u80FD\u52A9\u7406 \n \n \u4E2A\u4EBA \u77E5\u8BC6\u667A\u80FD\u52A9\u7406\uFF08KMAgent, Knowledge Management Agent\uFF09--\u4E13\u6CE8\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406GTD \u591A\u5143\u878D\u5408\u521B\u65B0 \u53D1\u626C\u4F20\u627F\u667A\u6167\uFF01 \n KMAgent \u4EE5 \u4E2A\u4EBA\u77E5\u8BC6\u7BA1\u7406 GTD \u5E94\u7528\u4E3A\u4E3B\u7684\u5DE5\u5177\u6548\u7387\u8F6F\u4EF6\u3002\u57FA\u4E8E\u4EA4\u4E92\u533A+\u6587\u6863\u7684\u534F\u540C\u5B66\u4E60\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u4E13\u6CE8\u4E8E\u8BED\u4E49\u8BA1\u7B97\u3001\u77E5\u8BC6\u5DE5\u7A0B\uFF0C\u81F4\u529B\u4E8E\u901A\u8FC7\u81EA\u7136\u8BED\u8A00\u5904\u7406\u3001\u673A\u5668\u5B66\u4E60\u3001\u77E5\u8BC6\u56FE\u8C31\u7B49\u4EBA\u5DE5\u667A\u80FD\u6280\u672F\uFF0C\u7B80\u5316\u77E5\u8BC6\u589E\u5F3A\u8BA4\u77E5\u3001\u878D\u5408\u652F\u6301\u4F18\u79C0\u65B9\u6CD5\u8BBA\u6A21\u677F\uFF0C\u8F85\u52A9\u9AD8\u6548\u5B66\u4E60\u5DE5\u4F5C\uFF0C\u6269\u5C55\u4E2A\u4EBA\u80FD\u529B\uFF0C\u7C7B\u4F3C\u94A2\u94C1\u4FA0\u7684\u3010\u8D3E\u7EF4\u65AF\u3011\u3002\u4EE5\u5F00\u6E90\u9879\u76EE\u7684\u5F62\u5F0F\u7ED3\u5408\u4EA7\u5B66\u7814\uFF0C\u652F\u6301\u793E\u7FA4\u534F\u540C\u79EF\u7D2F\u521B\u65B0\uFF0C\u8282\u7701\u65F6\u95F4\u7CBE\u529B\uFF0C\u4ECE\u77E5\u8BC6\u4E2D\u6316\u6398\u667A\u6167\u3002\u60A8\u7684\u79C1\u4EBA\u77E5\u8BC6\u5F15\u64CE\u3001\u79D8\u4E66\u3001\u667A\u53CB\u3001\u667A\u56CA\u56E2\u3002 \n \u8BF7\u67E5\u770B\u7F51\u7AD9 http://kmagent.com \u83B7\u53D6\u76F8\u5173\u5B89\u88C5\u6307\u5357\u53CA\u4F7F\u7528\u8BF4\u660E\u3002 \n \u4E3A\u4EC0\u4E48Why? \n \n \u7279\u522B\u91CD\u8981\u7684\u4E24\u4E2A\u80FD\u529B\uFF1A1\u3001\u5236\u9020\u5DE5\u5177\uFF1B2\u3001\u5BFB\u6C42\u5408\u4F5C\u3002 \n \n \u667A\u80FD\u65F6\u4EE3\uFF0C\u4FE1\u606F\u7206\u70B8\uFF0C\u77E5\u8BC6\u532E\u4E4F\uFF0C\u8F85\u52A9\u505A\u51CF\u6CD5\uFF01\u534F\u540C\u5408\u4F5C\uFF0C\u964D\u4F4E\u4FE1\u606F\u71B5\uFF0C\u63D0\u9AD8\u667A\u5546\uFF0C\u6781\u7B80\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406\uFF01 \n \n \n \u77E5\u8BC6\u8D22\u5BCC \uFF0C\u79EF\u7D2F\u77E5\u8BC6\u80DC\u8FC7\u79EF\u7D2F\u91D1\u94B1\uFF0C\u77E5\u8BC6\u662F\u4EBA\u7C7B\u8FDB\u6B65\u7684\u9636\u68AF\u3002\u662F\u4E2A\u4EBA\u53CA\u4F01\u4E1A\u7684\u6838\u5FC3\u7ADE\u4E89\u529B\uFF01 \n \u5316\u7E41\u4E3A\u7B80 \uFF0C\u53D1\u73B0\u6A21\u5F0F\u5316\u7E41\u4E3A\u7B80\uFF0C\u6316\u6398\u672C\u8D28\u53CA\u5173\u8054\uFF0C\u77E5\u5176\u7136\u77E5\u5176\u6240\u4EE5\u7136\uFF0C\u4FC3\u8FDB\u878D\u5408\u521B\u65B0\u3002 \n \u4EBA\u7C7B\u667A\u80FD \uFF0C\u6316\u6398\u9690\u6027\u77E5\u8BC6\u3001\u7406\u89E3\u4EBA\u7C7B\u591A\u5143\u667A\u80FD\uFF0C\u53D1\u6398\u5229\u7528\u5927\u8111\u6F5C\u529B\uFF0C\u6311\u6218\u8BA4\u77E5\u6781\u9650\u3002 \n \u77E5\u8BC6\u4F20\u64AD \uFF0C\u9759\u6001\u6587\u672C\u4E66\u7C4D\u7684\u7F3A\u9677\u3001\u63A2\u7D22\u65B0\u7684\u77E5\u8BC6\u5B58\u50A8\u5C55\u793A\u5206\u4EAB\u65B9\u5F0F\uFF0C\u5EFA\u7ACB\u9AD8\u6548\u6C9F\u901A\u534F\u540C\u4E0E\u79EF\u7D2F\u5206\u4EAB\u7684\u57FA\u7840\u3002 \n \u5B9E\u73B0\u5E94\u5BF9\u4EBA\u5DE5\u667A\u80FD \uFF0C\u77E5\u8BC6\u4E0E\u667A\u80FD\u76F8\u8F85\u76F8\u6210\uFF0C\u77E5\u8BC6\u7BA1\u7406\u4F5C\u4E3A\u6838\u5FC3\u73AF\u8282\uFF0C\u627F\u4E0A\u542F\u4E0B\u5F62\u6210\u95ED\u73AF\uFF0C\u793E\u7FA4\u534F\u540C\u79EF\u7D2F\u521B\u65B0\u3002 \n \u91CD\u65B0\u9020\u8F6E\u5B50 \uFF0C\u4E3A\u81EA\u5DF1\u5F00\u53D1\u4E00\u4E2A\u5DE5\u5177\uFF0C\u81EA\u7136\u4EA4\u4E92\u964D\u4F4E\u5DE5\u5177\u5B66\u4E60\u4F7F\u7528\u6210\u672C\uFF0C\u652F\u6301\u5B66\u4E60\u5DE5\u4F5C\u751F\u6D3B\u3002 \n \u4F5C\u4E3A\u4E8B\u4E1A \uFF0C\u503C\u5F97\u594B\u6597\u5341\u5E74\u7684\u4E8B\u4E1A\u3002 \n \n Do something diferent, make a change! \n \n \u3010\u4EA7\u54C1\u7B80\u4ECB\u3011\u4EA7\u54C1\u539F\u578B\u6B63\u706B\u901F\u5F00\u53D1\u4E2D\uFF01 \n \n \u662F\u4EE5\u6587\u6863+\u4EA4\u4E92\u533A\u4E3A\u4E2D\u5FC3\u7684\u529F\u80FD\u96C6\u6210\uFF0C\u8D44\u6E90\u4E8B\u52A1\u884C\u4E3A\u7684\u534F\u540C\u667A\u80FD\u7BA1\u7406GTD\u3002\u9996\u5148\u7528\u4E8E\u534F\u540C\u5EFA\u7ACB\u6838\u5FC3\u6982\u5FF5\u7406\u8BBA\u4F53\u7CFB\uFF0C\u77E5\u8BC6\u7BA1\u7406\u4E1A\u52A1\u5EFA\u6A21\uFF0C\u79EF\u7D2F\u5206\u4EAB\u8D44\u6E90\u77E5\u8BC6\u6280\u672F\uFF0C\u5E94\u7528\u4E8EKM\u3001IT\u3001AI\u3001\u6570\u5B66\u76F8\u5173\u9886\u57DF\u77E5\u8BC6\u7684\u5B66\u4E60\u6574\u7406\u3002 \n \n \u529F\u80FD\u53CA\u7279\u6027\uFF1A \n \n \u591A\u5A92\u4F53\u65E0\u9650\u753B\u677F\u3001\u5B9E\u65F6\u534F\u540C\u6587\u672C\u5BFC\u56FE\u7F16\u8F91\u5668\uFF0C\u5BCC\u6587\u672C\u548C Markdown \u6269\u5C55\u7F16\u8F91\u3002 \n \u652F\u6301\u672C\u4F53\u5EFA\u6A21\u3001\u9605\u8BFB\u7B14\u8BB0\u3001\u7075\u611F\u4FBF\u7B7E\u3001\u601D\u7EF4\u5BFC\u56FE\u3001\u5404\u7C7B\u6A21\u677F\u3002 \n \u5212\u8BCD\u7FFB\u8BD1\u77E5\u8BC6\u89E3\u91CA\u3001\u641C\u7D22\u3001\u767E\u79D1\u5B57\u5178\u3002 \n \u77E5\u8BC6\u53EF\u89C6\u5316\uFF0C\u591A\u5C42\u6B21\u7C92\u5EA6\u7EF4\u5EA6\u53BB\u5197\u4F59\uFF0C\u6D53\u7F29\u6458\u8981\u3001\u751F\u6210\u535A\u5BA2\u3002 \n \u77E5\u8BC6\u5BFC\u5165\u5BFC\u51FA\u3001Web \u77E5\u8BC6\u62BD\u53D6\u96C6\u6210\u3002 \n \u8D44\u6E90\u7BA1\u7406\u3001\u516C\u5171+\u4E2A\u4EBA+\u9886\u57DF\u77E5\u8BC6\u56FE\u8C31\u3002 \n \u6536\u85CF\u8BA2\u9605\u8BC4\u8BBA\u5206\u4EAB\u3001\u8BDD\u9898\u8BFE\u7A0B\u5C0F\u7EC4\u73ED\u7EA7\u5708\u5B50\u3002 \n \u9879\u76EE\u4E8B\u52A1\u7684PDCA\u3001GTD\uFF0C\u65E5\u5386\u65E5\u7A0B\u5B89\u6392\u63D0\u9192\u3002 \n \u5373\u65F6\u901A\u4FE1\u3001\u5B9E\u65F6\u534F\u540C\u3001\u9879\u76EE\u5408\u4F5C\u3001\u79EF\u5206\u7CFB\u7EDF\u3002 \n \u4E2A\u6027\u5316\u81EA\u5B66\u4E60\u804A\u5929\u673A\u5668\u4EBA\u3001\u865A\u62DF\u5F62\u8C61\u3001\u8BED\u97F3\u8BC6\u522B\u751F\u6210\u3001\u4E8B\u52A1\u4EE3\u7406\u3001\u4E3B\u52A8\u63A8\u8350\u63D0\u9192\u5F15\u5BFC\u8F85\u52A9\u3002 \n \u81EA\u7136\u8BED\u8A00\u4EA4\u4E92\u3001\u8BED\u4E49\u5316\u3001\u54CD\u5E94\u5F0F\u751F\u6210\u5F0F\u3001\u6587\u672C\u5316\u3001\u53EF\u89C6\u5316\u3001\u6781\u81F4\u6C89\u6D78\u4F53\u9A8C\u3002 \n \u9AD8\u7EA7\u529F\u80FD\uFF1A\u81EA\u5B9A\u4E49\u914D\u7F6E\u3001\u63D2\u4EF6\u3001\u547D\u4EE4\u884C\u3001\u9886\u57DF\u8BED\u8A00\u3002 \n \n \u8F85\u52A9\u60A8\u8FDB\u884C\u6781\u7B80\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406\uFF1A\u77E5\u8BC6\u53EF\u89C6\u5316\u521B\u4F5C\u5C55\u793A\uFF0C\u7B80\u5316\u7ED3\u6784\u5316\u5DF2\u6709\u77E5\u8BC6\u8D44\u6E90\uFF0C\u5EFA\u7ACB\u77E5\u8BC6\u4F53\u7CFB\u3002\u6DF1\u5165\u672C\u8D28\u7406\u89E3\u77E5\u8BC6\u3001\u6574\u4F53\u9AD8\u6548\u5408\u4F5C\u5B66\u4E60\u3002\u4E2A\u4EBA\u4E8B\u52A1\u7684\u7BA1\u7406\u3001\u539F\u5219\u65B9\u6CD5\u8BBA\u4E60\u60EF\u7684\u517B\u6210\u3002\u8BED\u4E49\u8BA1\u7B97\uFF0C\u8F85\u52A9\u63A8\u7406\u3001\u4EFF\u771F\u3001\u9884\u6D4B\u3001\u51B3\u7B56\u3002\u804A\u5929\u89E3\u95F7\u542F\u53D1\u3002 \n \u5F88\u9AD8\u5174\u60A8 \u4E0B\u8F7D\u8BD5\u7528 \u5E76 \u56DE\u9988\u4F7F\u7528\u60C5\u51B5 \u3002 \n \n \u968F\u7740\u5F00\u53D1\u8FDB\u5C55\uFF0C\u4F1A\u53CA\u65F6\u5217\u51FA\u6700\u65B0\u7279\u6027\u3001\u65B0\u529F\u80FD\u53CA\u6539\u8FDB\u60C5\u51B5\u3002\u67E5\u770B v0.1 -&gt; v1.0 \u5347\u7EA7\u4FE1\u606F \uFF0C\u83B7\u53D6\u66F4\u591A\u4EA7\u54C1\u5347\u7EA7\u4FE1\u606F \u3002 \n \u3010\u53C2\u4E0E\u8D21\u732E\u3011 \n \n \u6211\u4EEC\u662F\u4E00\u4E2A\u534F\u540C\u5B66\u4E60\u578B\u7EC4\u7EC7\uFF0C\u4EE5\u5F00\u6E90\u9879\u76EE\u4E3A\u4E2D\u5FC3\uFF0C\u7ED3\u5408\u4EA7\u5B66\u7814\uFF0C\u7406\u8BBA\u6280\u672F\u77E5\u8BC6\u80FD\u529B\u5B9E\u8DF5\u95ED\u73AF\u6B63\u53CD\u9988\u8FED\u4EE3\u79EF\u7D2F\u7684\u8FC7\u7A0B\uFF0C\u4EBA\u4E0E\u4EBA\u4E0E\u673A\u5668\u673A\u5668\u7684\u5408\u4F5C\u5B66\u4E60\uFF01\u9879\u76EE\u5904\u4E8E\u521D\u671F\u89C4\u5212\u9636\u6BB5\uFF0C \u6B22\u8FCE\u5404\u4F4D\u6709\u5FD7\u4E4B\u58EB\u7684\u52A0\u5165\uFF01 \n \n \u57FA\u4E8E\u5171\u540C\u4FE1\u5FF5\u3001\u7EDF\u4E00\u57FA\u7840\u3001\u534F\u540C\u673A\u5236\uFF0C\u81EA\u7531\u5206\u5DE5\u5408\u4F5C\u7684\u5DE5\u4F5C\u7EC4\uFF0C\u53EF\u9009\u62E9\u4E00\u4E2A\u6216\u591A\u4E2A\u6A21\u5757\u53C2\u4E0E\u5408\u4F5C\u5B66\u4E60\u53CA\u5F00\u53D1\uFF0C\u6839\u636E \u89C4\u5219 \u8BB0\u5F55\u8D21\u732E\u79EF\u5206\uFF0C\u6309\u8D21\u732E\u5206\u914D\u5956\u52B1\uFF0C\u672A\u6765\u82E5\u76C8\u5229\u53EF\u5206\u7EA2\uFF0C\u6D8C\u73B0\u96C6\u4F53\u667A\u6167\uFF01\u6B22\u8FCE\u6BCF\u4E2A\u4EBA\u8D21\u732E\u529B\u91CF\u3001\u6536\u83B7\u79EF\u5206\u670B\u53CB\u77E5\u8BC6\u5DE5\u5177\u6280\u672F\u3002 \n \u3010\u503C\u5F97\u52A0\u5165\u3011\u77E5\u8BC6\u6539\u53D8\u547D\u8FD0\uFF0C\u521B\u65B0\u6539\u53D8\u4E16\u754C\uFF01\u6539\u53D8\u81EA\u5DF1\u4ECE\u5FC3\u800C\u4E3A\uFF0C\u4E0D\u5FD8\u521D\u5FC3\u65B9\u5F97\u59CB\u7EC8\uFF01 \n \u591A\u79CD\u8D21\u732E\u65B9\u5F0F \n \n \u53EF\u53C2\u4E0E\u7406\u8BBA\u7814\u7A76\u3001\u4E1A\u52A1\u5EFA\u6A21\u3001\u6280\u672F\u5F00\u53D1\u3001\u9879\u76EE\u7BA1\u7406\u3001\u8FD0\u8425\u3001\u6295\u8D44\u3001\u8BD5\u7528\u5206\u4EAB\u63A8\u5E7F\u3002 \n \u63D0\u4EA4\u6216\u6295\u7968\u65B0\u529F\u80FD\u7279\u6027\u9700\u6C42 ProductPains \n \u5DE5\u5177\u4F7F\u7528 \u60C5\u51B5\u53CD\u9988 \n \n \u6B22\u8FCE\u63D0\u4EA4 pull requests \u53CA issue \u3002 \n \u82E5\u8D21\u732E\u6E90\u7801\u8BF7\u9605\u8BFB\u9075\u5FAA \u7F16\u7A0B\u98CE\u683C \u53CA \u8D21\u732E\u8BF4\u660E\u6587\u6863 \u3002 \n \u81F4\u8C22 \n \u3010\u6E90\u8BA1\u5212\u3011KMAgent \u5F53\u524D\u662F\u4E00\u4E2A\u516C\u5F00\u793E\u7FA4\u548C\u514D\u8D39\u8F6F\u4EF6\uFF0C\u611F\u8C22\u6240\u6709\u4FC3\u8FDB\u5176\u53D1\u5C55\u7684 \u8D21\u732E\u8005 \u548C [\u6DF1\u5EA6\u7528\u6237]( https://github.com/kmagent/ kmagent/fans.md)\u3002\u3010\u6350\u8D60\u3011\u5982\u679C\u60A8\u8BA4\u540C\u6211\u4EEC\u8BF7\u652F\u6301\u6211\u4EEC\u5FEB\u901F\u6301\u7EED\u53D1\u5C55\u3002 \n \u4E3B\u8981\u6A21\u5757 \n \u3010\u6838\u5FC3\u91CD\u70B9\u3011\u667A\u80FD\u4F53\u8BED\u4E49\u5143\u6838\u5FC3\u62BD\u8C61\u3001\u8BA4\u77E5\u5EFA\u6A21\u3001\u77E5\u8BC6\u56FE\u8C31\u3001\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406GTD\u89E3\u51B3\u65B9\u6848\u3001\u4EA7\u54C1\u8BBE\u8BA1\u5F00\u53D1\uFF0C\u793E\u7FA4\u8FD0\u8425\u534F\u540C\u79EF\u7D2F\u521B\u65B0\u3002\uFF08\u667A\u80FD\u57FA\u7840-&gt;\u667A\u80FD\u6838-&gt;\u667A\u80FD\u5757-&gt;\u667A\u80FD\u4F53\uFF09\u7FA4\u4F53\u667A\u80FD-&gt;\u901A\u7528\u667A\u80FD\uFF0C\u6A21\u62DF-&gt;\u8D85\u8D8A\u3002\u6A21\u5757\uFF1Akm-thory km-engine km-onto km-agents km-sys km-ui\u3001km-graph\u3002 \n \u3010\u9886\u57DF\u53CA\u6280\u672F\u3011\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406\uFF08\u9886\u57DF\u5EFA\u6A21\uFF09\u3001\u673A\u5668\u5B66\u4E60\uFF08tensorflow\uFF09\u3001\u81EA\u7136\u8BED\u8A00\u5904\u7406\uFF08NLTK\u3001hanlp\uFF09\u3001\u77E5\u8BC6\u56FE\u8C31\uFF08\u56FE\u6570\u636E\u5E93neo4j\u5206\u5E03\u5F0F\u5B58\u50A8ceph\uFF09\u3001\u9886\u57DF\u8BED\u8A00\uFF08DSL\uFF09\u3001\u8BED\u4E49\u7F51\uFF08OWL\uFF09\u3001web\u77E5\u8BC6\u53D1\u73B0\uFF08\u722C\u866B\uFF09\u3001\u68C0\u7D22\uFF08lucene\uFF09\u63A8\u7406\u63A8\u8350\u3001\u591Aagent\u96C6\u7FA4\u667A\u80FD\uFF08\u67B6\u6784\uFF09\u3001\u4EBA\u673A\u4EA4\u4E92UI\uFF08vue.js\u3001bootstrap\u3001\u6570\u636E\u53EF\u89C6\u5316\uFF09\u3001Web\u7F51\u7AD9\uFF08keystone\uFF09\u3001\u684C\u9762\uFF08webkit\u3001electron\uFF09\u3001\u79FB\u52A8\uFF08weex\uFF09\u3001\u5927\u6570\u636E\uFF08spark\uFF09\u3001\u865A\u62DF\u5316\u4E91\u8BA1\u7B97\uFF08Mesos\u3001docker\u3001Kubernetes\uFF09\u3001\u5B89\u5168\u7F51\u7EDC\u901A\u4FE1\u52A0\u5BC6\u6743\u9650\u8BA4\u8BC1\uFF08openSSL\uFF09\u3001\u8F6F\u4EF6\u5DE5\u7A0B\uFF08\u9879\u76EE\u5F00\u53D1\u7BA1\u7406\uFF09\u3001\u533A\u5757\u94FE\u3001VR\u3001\u4EE3\u7801\u751F\u6210\u3001\u8BA4\u77E5\u5FC3\u7406\u3001\u590D\u6742\u7CFB\u7EDF\u3001\u77E5\u8BC6\u5171\u4EAB\u534F\u8BAE\u4EA7\u6743\u3001\u793E\u7FA4\u4F53\u9A8C\u7ECF\u6D4E\u3002 \n \u3010\u5DE5\u4F5C\u5206\u89E3\u3011 \u5173\u952E\u5728\u4E8E \uFF1A\u7EDF\u4E00\u8BA4\u8BC6\u3001\u5DE5\u5177\u652F\u6301\u3001\u6709\u6548\u79EF\u7D2F\u53EF\u6301\u7EED\u53D1\u5C55\u3002 \n \n \u4E1A\u52A1\u5EFA\u6A21\uFF08\u667A\u80FD\u77E5\u8BC6\u7BA1\u7406GTD\u7406\u8BBA\u4F53\u7CFB\uFF09\uFF1A\u6838\u5FC3\u62BD\u8C61\u6A21\u578B\uFF0C\u4EBA\u6027\u5EFA\u6A21\u3002 \n \u4EA7\u54C1\u8BBE\u8BA1\uFF08\u4E2A\u4EBA\u667A\u80FD\u52A9\u7406\uFF09\uFF1A\u4EA7\u54C1\u89C4\u5212\u3001\u865A\u62DF\u5F62\u8C61UI\u8BBE\u8BA1\u3001\u7ADE\u54C1\u5206\u6790\u3002 \u53C2\u8003\u4EA7\u54C1 \uFF1Aprotege\u3001vscode\u3001quip\u3001knowledgebuilder\u3001metacademy\u3001wiki\u3001CSDN\u77E5\u8BC6\u5E93\u3001sketchboard\u3001feedly\u3001onenote\u753B\u677F\u3001foxmail\u3001\u4EAC\u4E1C\u9605\u8BFB\u3001qq\u97F3\u4E50\u3001NetLogo\u3001flyinglogic\u3001sourceinsight\u3001\u5E55\u5E03\u3001Anki\u3001wolframalpha\u3002 \n \u6280\u672F\u67B6\u6784\uFF08\u901A\u7528\u667A\u80FD\u7CFB\u7EDF\uFF09\uFF1A\u5206\u5E03\u5F0F\u8BA1\u7B97\u5B58\u50A8\u591A\u667A\u80FD\u4F53\u534F\u540C\u7CFB\u7EDF\uFF1A\u666E\u9002\u7F51\u683C\u8BED\u4E49\u4EBA\u7C7B\u8BA1\u7B97\u3002\u5168\u5E73\u53F0\u3001\u5FAE\u670D\u52A1\u3001\u6838\u5FC3\u7B97\u6CD5\u3001\u6280\u672F\u9009\u578B\u3001\u6D4B\u8BD5\u90E8\u7F72\u3002C++\u3001Python\u3001js\u3001HTML\u3002 \n \u5546\u4E1A\u8BA1\u5212\uFF08SaaS \u8F6F\u4EF6\u5373\u670D\u52A1\uFF09\uFF1A\u4EE5\u8F6F\u4EF6\u4EA7\u54C1\u4E3A\u4E2D\u5FC3\u7684\u589E\u503C\u670D\u52A1\u3001\u54C1\u724C\u8FD0\u8425\u63A8\u5E7F\u8425\u9500\u3002 \n \u9879\u76EE\u7BA1\u7406\uFF08\u5C0F\u4EE3\u4EF7\u8FBE\u5230\u76EE\u7684\uFF09\uFF1A\u654F\u6377\u8FED\u4EE3\u3001\u8FC7\u7A0B\u6539\u8FDB\u3001\u914D\u7F6E\u7BA1\u7406\u3002 \n \u793E\u7FA4\u5EFA\u8BBE\uFF08\u5229\u76CA\u5171\u540C\u4F53\u8054\u76DF\uFF09\uFF1A\u6587\u5316\u7406\u5FF5\u96C6\u4F53\u667A\u6167\u3001\u6269\u5927\u5F71\u54CD\u3002 \n \u77E5\u8BC6\u521B\u4F5C\uFF08\u77E5\u8BC6\u7BA1\u7406\u7B49\u9886\u57DF\u77E5\u8BC6\uFF09\uFF1A\u77E5\u8BC6\u7BA1",
-      image: "https://opengraph.githubassets.com/935c4954d4a340aff679b550e201df566a4f53b442922a997e8a83570a564195/putaodoudou/kmagent",
-      favicon: "https://github.com/fluidicon.png"
-    }
-  ],
-  costDollars: {
-    total: 0.015,
-    search: {
-      neural: 5e-3
-    },
-    contents: {
-      text: 0.01
-    }
-  }
-};
-
-// src/functions/exa/data/exa-search-1748337344119.ts
-var exa_search_1748337344119_default = {
-  requestId: "32df0c541f9883180b35e04caece4374",
-  autopromptString: "open source AI knowledge management projects features comparison 2024",
-  autoDate: "2024-01-01T00:00:00.000Z",
-  resolvedSearchType: "neural",
-  results: [
-    {
-      id: "https://tryfastgpt.ai/",
-      title: "FastGPT",
-      url: "https://tryfastgpt.ai/",
-      publishedDate: "2024-01-01T00:00:00.000Z",
-      author: "labring",
-      score: 0.36898404359817505,
-      text: "20w+\xA0 Users are leveraging FastGPT to create their own specialized AI knowledge bases Empowerwith Your Expertise A free, open-source, and powerful AI knowledge base platform, offers out-of-the-box data processing, model invocation, RAG retrieval, and visual AI workflows. Easily build complex LLM applications. Features Why Choose FastGPT? Discover the advantages of FastGPT Open Source Secure and reliable open-source codebase. Optimized Q&amp;A Enhanced question-answering accuracy for customer service. Visual Workflow Design complex workflows with ease using the Flow module. Seamless Extensibility Seamlessly integrate FastGPT into your applications via API. Debugging Tools Refine your models with comprehensive debugging features. Multi-Model Compatibility Compatible with various LLM models, with more to come. Do you find this open-source AI knowledge base platform valuable?\xA0 Show your support by giving us a star \u{1F31F} FAQ Find answers to the most common inquiries here. FastGPT allows commercial usage, such as serving as a backend service for other applications or as an application development platform for enterprises. However, when it comes to multi-tenant SaaS services or matters involving the LOGO and copyright information, you must contact the author to obtain a commercial license. FastGPT supports importing documents in various formats, including Word, PDF, Excel, Markdown, and web links. It also enables syncing data from an entire website, automatically handling text preprocessing, vectorization, and QA splitting, which saves manual training time and improves efficiency. As long as the API of the model you want to integrate aligns with the official OpenAI API, it can be used with FastGPT. You can utilize projects like One API to unify access to different models and provide an API that is compatible with the official OpenAI API. If you come across any problems while using FastGPT, please join our community or forum, create a post, and reach out to us for assistance.",
-      favicon: "https://tryfastgpt.ai/favicon-16x16.png"
-    },
-    {
-      id: "https://casibase.org",
-      title: "Casibase | Casibase \xB7 Open-Source LangChain-like AI Knowledge Database & Chat Bot with Admin UI and multi-model support (ChatGPT, Claude, Llama 3, DeepSeek R1, HuggingFace, etc.)",
-      url: "https://casibase.org",
-      publishedDate: "2025-01-01T00:00:00.000Z",
-      author: "",
-      score: 0.354640930891037,
-      text: "Comprehensive Model Support Integrates a diverse range of AI models, including ChatGPT, Azure OpenAI, HuggingFace, and more, complemented by support for various embedding APIs like OpenAI Ada and Baidu Wenxin Yiyi. Advanced Document Handling &amp; AI Assistance Supports multiple document formats including txt, markdown, docx, pdf with intelligent parsing, and features an embedded AI assistant for real-time online chat and manual session handover. Enterprise-Level Features &amp; Multilingual Support Offers multi-user and multi-tenant capabilities with enterprise-grade Single Sign-On (SSO), comprehensive chat session logging for auditing, and a multilingual interface supporting Chinese, English, and more. Casibase is an open source AI knowledge base and dialogue system that combines the latest RAG (Retrieval Augmented Generation) technology, enterprise-grade Single Sign-On (SSO) functionality, and support for a wide range of mainstream AI models. Casibase is designed to provide enterprises and developers with a powerful, flexible, and easy-to-use knowledge management and intelligent dialogue platform. Casibase provides various provider configurations, such as storage providers, model providers, embedding providers, etc. To chat with AI easily, please visit the Casibase Guide for more details. Enterprise-class identity management capabilities Casibase uses Casdoor as its identity and single sign-on (SSO) provider. Through its deep integration with Casdoor, Casibase not only simplifies the user login process, but also provides a high level of security and flexibility, enabling organisations to easily manage user identities and access rights.",
-      favicon: "https://casibase.org/img/favicon.png"
-    },
-    {
-      id: "https://www.open-notebook.ai/",
-      title: "What is Open Notebook? | Open Notebook",
-      url: "https://www.open-notebook.ai/",
-      publishedDate: "2024-01-01T00:00:00.000Z",
-      author: "",
-      score: 0.36405712366104126,
-      text: "Take Control of Your Learning. Privately. A powerful open-source, AI-powered note-taking/research platform that respects your privacy \u{1F399}\uFE0F Podcast Generator Transform your notes into engaging podcasts with customizable voices, speakers, and episodes \u{1F916} AI-Powered Notes Leverage AI to summarize, generate insights, and manage your notes \u{1F512} Privacy Control Full control over what information AI can access \u{1F504} Content Integration Support for links, PDFs, TXT, PPT, YouTube, and more What is Open Notebook? \u200B Open Notebook is the cognitive partner you always wanted and could never explain why. It combines the power of AI with unwavering privacy controls. It's designed for researchers, students, and professionals who want to enhance their learning and abilities while maintaining complete control over workflows, models, and how their data gets used and exposed. Is this right for me? \u200B \u{1F4DA} Learning Enthusiast You're constantly seeking knowledge and want to go beyond surface-level understanding. Learning for you is about building deep, lasting comprehension. \u{1F91D} You want a learning partner You believe your learning process can improve by partnering with a tailor made AI. You want to be provoked to think more clearly. \u{1F92F} Your learning backlog is way too big You have hundreds of links you would love to read, but there is no time for it all. You want to make sure those are catalogued for when you need them. \u270D\uFE0F Independent Thinker You value both taking notes and forming your own ideas. You understand different viewpoints but believe in developing your own perspective. \u{1F512} You are privacy aware You don't want all your context, thoughts and plans to be all over Big Tech, if not necessary. \u{1F481} You like things your way You want to decide how your content is handled, which AI models you want to interact with and help specifically it should help/challenge you. What is the plan for the future? \u200B There is much more that can be done to augment human knowledge. Open Notebook's first release is just a first step in that direction. The end goal is to build a Cognitive Partner for every person. A customized assistant that can help you develop your skills, knowledge, and opinions in a way that makes sense to you. Learn more about our long-term vision and roadmap in our Vision page."
-    },
-    {
-      id: "https://www.suna.so/",
-      title: "Suna - Open Source Generalist AI Agent",
-      url: "https://www.suna.so/",
-      publishedDate: "2025-06-21T00:00:00.000Z",
-      author: "Kortix Team",
-      score: 0.3588857054710388,
-      text: "100% OPEN SOURCE Suna, your AI Employee. Suna by Kortix \u2013 is a generalist AI Agent that acts on your behalf. See Suna in action Explore real-world examples of how Suna completes complex tasks autonomously Suna is fully open source. Join our community and help shape the future of AI. The Generalist AI Agent Explore, contribute, or fork our repository. Suna is built with transparency and collaboration at its core. TypeScript Python Apache 2.0 License View on GitHub Transparency &amp; Trust We believe AI should be open and accessible to everyone. Our open source approach ensures accountability, innovation, and community collaboration. Transparency Fully auditable codebase Community Join our developers Apache 2.0 Free to use and modify Choose the right plan for your needs Start with our free plan or upgrade to a premium plan for more usage hours Free $0 Get started with 60 min/month Public Projects Basic Model (Limited capabilities) Pro Popular $20 /month Everything in Free, plus: 2 hours/month 2 hours Private projects Access to intelligent Model (Full Suna) Custom $50 /month Everything in Pro, plus: Customize your monthly usage 6 hours/month Suited to you needs",
-      image: "https://suna.so/opengraph-image?971e689ec8d3b4eb",
-      favicon: "https://www.suna.so/favicon.png"
-    },
-    {
-      id: "https://github.com/AIDotNet/AntSK",
-      title: "GitHub - AIDotNet/AntSK: \u57FA\u4E8E.Net8+AntBlazor+SemanticKernel \u548CKernelMemory \u6253\u9020\u7684AI\u77E5\u8BC6\u5E93/\u667A\u80FD\u4F53\uFF0C\u652F\u6301\u672C\u5730\u79BB\u7EBFAI\u5927\u6A21\u578B\u3002\u53EF\u4EE5\u4E0D\u8054\u7F51\u79BB\u7EBF\u8FD0\u884C\u3002\u652F\u6301aspire\u89C2\u6D4B\u5E94\u7528\u6570\u636E",
-      url: "https://github.com/AIDotNet/AntSK",
-      publishedDate: "2024-02-01T15:08:17.000Z",
-      author: "AIDotNet",
-      score: 0.3635949492454529,
-      text: "\u7B80\u4F53\u4E2D\u6587 | English \n AntSK \n AI Knowledge Base/Intelligent Agent built on .Net8+AntBlazor+SemanticKernel \n \u2B50Core Features \n \n \n Semantic Kernel: Utilizes advanced natural language processing technology to accurately understand, process, and respond to complex semantic queries, providing users with precise information retrieval and recommendation services. \n \n \n Kernel Memory: Capable of continuous learning and storing knowledge points, AntSK has long-term memory function, accumulates experience, and provides a more personalized interaction experience. \n \n \n Knowledge Base: Import knowledge base through documents (Word, PDF, Excel, Txt, Markdown, Json, PPT) and perform knowledge base Q&amp;A. \n \n \n GPT Generation: This platform supports creating personalized GPT models, enabling users to build their own GPT models. \n \n \n API Interface Publishing: Exposes internal functions in the form of APIs, enabling developers to integrate AntSK into other applications and enhance application intelligence. \n \n \n API Plugin System: Open API plugin system that allows third-party developers or service providers to easily integrate their services into AntSK, continuously enhancing application functionality. \n \n \n.Net Plugin System: Open dll plugin system that allows third-party developers or service providers to easily integrate their business functions by generating dll in standard format code, continuously enhancing application functionality. \n \n \n Online Search: AntSK, real-time access to the latest information, ensuring users receive the most timely and relevant data. \n \n \n Model Management: Adapts and manages integration of different models from different manufacturers, models offline running supported by llamafactory and ollama. \n \n \n Domestic Innovation: AntSK supports domestic models and databases and can run under domestic innovation conditions. \n \n \n Model Fine-Tuning: Planned based on llamafactory for model fine-tuning. \n \n \n \u26EAApplication Scenarios \n AntSK is suitable for various business scenarios, such as: \n \n Enterprise knowledge management system \n Automatic customer service and chatbots \n Enterprise search engine \n Personalized recommendation system \n Intelligent writing assistance \n Education and online learning platforms \n Other interesting AI Apps \n \n \u270F\uFE0FFunction Examples \n Online Demo \n document \n demo \nand\n demo1 \n Default account: test\nDefault password: test\nDue to the low configuration of the cloud server, the local model cannot be run, so the system settings permissions have been closed. You can simply view the interface. If you want to use the local model, please download and use it on your own.\n \n Other Function Examples \n Video Demonstration \n \u2753How to get started? \n Here I am using Postgres as the data and vector storage because Semantic Kernel and Kernel Memory support it, but you can also use other options. \n The model by default supports the local model of openai, azure openai, and llama. If you need to use other models, you can integrate t",
-      image: "https://opengraph.githubassets.com/945bd786b32bfe02a9a537c511d768696a91e155dc07052bba541d1b3e6517c0/AIDotNet/AntSK",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://www.cognee.ai/",
-      title: "Improve your AI infrastructure - AI memory engine",
-      url: "https://www.cognee.ai/",
-      publishedDate: "2025-05-21T00:00:00.000Z",
-      author: "",
-      score: 0.3653402328491211,
-      text: "AI agent responses you can rely on AI Memory Python SDK. 90% accuracy out of the box. People use cognee to sort out their data and improve AI answers Ask cognee 89.4% answer relevancy Vector store Ask RAG Potato answer relevancy ChatGPT Ask ChatGPT 5% answer relevancy Improve responses from LLM applications Text generation Content summaries Customer analysis Chatbot responses Code generation Translations Why choose Cognee 1 It\u2019s free and open-source We\u2019re all about building in the open. Just install the Python library, or clone the repo from GitHub and start playing around. Super flexible for developers and hobbyists. 2 Totally customisable storage Want to use a different database provider? No problem. cognee supports many out of the box (like vector and graph databases), but you can easily plug in your own by following the docs. 3 Smart data with ontologies Cognee isn\u2019t just storing random chunks of data - everything is related! RDF-based ontologies define the structure with publicly available rules and ontologies to make your data even smarter. 4 Actual reasoning (no guessing here!) Instead of just guessing based on patterns, cognee can use real reasoners. You can use existing ones, or build your own for your specific case. 5 Built for your servers You can run everything on your own servers, so if you\u2019re dealing with sensitive data there\u2019s no third-party risk. 6 Handles loads of data Need to analyse a lot of data? Whether it\u2019s gigabytes (or terabytes :hushed:) cognee\u2019s distributed system can handle it. It scales exactly when you need it to. 1 It\u2019s free and open-source We\u2019re all about building in the open. Just install the Python library, or clone the repo from GitHub and start playing around. Super flexible for developers and hobbyists. 3 Smart data with ontologies Cognee isn\u2019t just storing random chunks of data - everything is related! RDF-based ontologies define the structure with publicly available rules and ontologies to make your data even smarter. 5 Built for your servers You can run everything on your own servers, so if you\u2019re dealing with sensitive data there\u2019s no third-party risk. 2 Totally customisable storage Want to use a different database provider? No problem. cognee supports many out of the box (like vector and graph databases), but you can easily plug in your own by following the docs. 4 Actual reasoning (no guessing here!) Instead of just guessing based on patterns, cognee can use real reasoners. You can use existing ones, or build your own for your specific case. 6 Handles loads of data Need to analyse a lot of data? Whether it\u2019s gigabytes (or terabytes :hushed:) cognee\u2019s distributed system can handle it. It scales exactly when you need it to. Success case Increased answer relevancy with more support agents using the tool. Helping Dynamo increase customer engagement Problem Dynamo helps gaming companies interact with their user base. Agents communicate via messenger to offer bonuses and encourage participation in tournaments a",
-      image: "https://www.cognee.ai/images/meta/cognee-logo-text-on-gradient.png",
-      favicon: "https://www.cognee.ai/favicon.ico"
-    },
-    {
-      id: "https://github.com/AI4WA/Docs2KG",
-      title: "GitHub - AI4WA/Docs2KG: Docs2KG: A Human-LLM Collaborative Approach to Unified Knowledge Graph Construction from Heterogeneous Documents",
-      url: "https://github.com/AI4WA/Docs2KG",
-      publishedDate: "2024-05-08T15:21:54.000Z",
-      author: "AI4WA",
-      score: 0.36111196875572205,
-      text: "Docs2KG \n A Human-LLM Collaborative Approach to Unified Knowledge Graph Construction from Heterogeneous Documents \n \n \n \n \n \n \n Installation \n We have published the package to PyPi: Docs2KG, \n You can install it via: \n pip install Docs2KG\npython -m spacy download en_core_web_sm \n \n \n \n Setup and Tutorial \n Detailed setup and tutorial can be found in the documentation. \n You have two ways to run the package: \n \n import the package in the code, and hook it with your own code \n run the package in the command line \n \n Command Line \n # first setup the CONFIG_FILE environment variable to local one \n export CONFIG_FILE=config.yml # or any other path for the configuration file \ndocs2kg # this command will tell you how to use the package \n # we currently support the following commands \ndocs2kg process-document your_input_file --agent-name phi3.5 --agent-type ollama --project-id your_project_id\ndocs2kg batch-process your_input_dir --agent-name phi3.5 --agent-type ollama --project-id your_project_id\ndocs2kg list-formats # list all the supported formats \n Usage: docs2kg [OPTIONS] COMMAND [ARGS]...\n Docs2KG - Document to Knowledge Graph conversion tool.\n Supports multiple document formats: PDF, DOCX, HTML, and EPUB.\nOptions:\n -c, --config PATH Path to the configuration file (default: ./config.yml)\n --help Show this message and exit.\nCommands:\n batch-process Process all supported documents in a directory.\n list-formats List all supported document formats.\n neo4j Load data to Neo4j database.\n process-document Process a single document file.\n \n Usage: docs2kg process-document [OPTIONS] FILE_PATH\n Process a single document file.\n FILE_PATH: Path to the document file (PDF, DOCX, HTML, or EPUB)\nOptions:\n -p, --project-id TEXT Project ID for the knowledge graph construction\n -n, --agent-name TEXT Name of the agent to use for NER extraction\n -t, --agent-type TEXT Type of the agent to use for NER extraction\n --help Show this message and exit.\n \n Usage: docs2kg neo4j [OPTIONS] PROJECT_ID\n Load data to Neo4j database.\nOptions:\n -m, --mode [import|export|load|docker_start|docker_stop]\n Mode of operation (import or export)\n -u, --neo4j-uri TEXT URI for the Neo4j database\n -U, --neo4j-user TEXT Username for the Neo4j database\n -P, --neo4j-password TEXT Password for the Neo4j database\n -r, --reset_db Reset the database before loading data\n --help \n \n Motivation \n To digest diverse unstructured documents into a unified knowledge graph, there are two main challenges: \n \n How to get the documents to be digitized? \n \n With the dual-path data processing\n \n For image based documents, like scanned PDF, images, etc., we can process them through the layout analysis and\nOCR, etc. Docling and MinerU are focusing on this part. \n For native digital documents, like ebook, docx, html, etc., we can process them through the programming parser \n \n \n It is promising that we will have a robust solution soon. \n \n \n How to construct a high-quality unified knowledge graph with less effort? \n \n Fo",
-      image: "https://opengraph.githubassets.com/170da8210f59c1e9bb44ebe1ee84b35e1fd9d3d74d1aec22323534770d4921af/AI4WA/Docs2KG",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://github.com/RoboZoom/knowledge_management",
-      title: "GitHub - RoboZoom/knowledge_management",
-      url: "https://github.com/RoboZoom/knowledge_management",
-      publishedDate: "2024-02-08T02:20:22.000Z",
-      author: "RoboZoom",
-      score: 0.37371376156806946,
-      text: "\n \n \n \n \n \n \n \n \n \n \nGitHub Copilot\n \nWrite better code with AI\n \n \n \n \n \n \nGitHub Models\n \nNew\n \n \nManage and compare prompts\n \n \n \n \n \n \nGitHub Advanced Security\n \nFind and fix vulnerabilities\n \n \n \n \n \n \nActions\n \nAutomate any workflow\n \n \n \n \n \n \nCodespaces\n \nInstant dev environments\n \n \n \n \n \n \n \n \n \n \nIssues\n \nPlan and track work\n \n \n \n \n \n \nCode Review\n \nManage code changes\n \n \n \n \n \n \nDiscussions\n \nCollaborate outside of code\n \n \n \n \n \n \nCode Search\n \nFind more, search less\n \n \n \n \n \n \n \n \n \n \n Explore \n \n \nLearning Pathways\n \n \n \nEvents &amp; Webinars\n \n \n \nEbooks &amp; Whitepapers\n \n \n \nCustomer Stories\n \n \n \nPartners\n \n \n \nExecutive Insights\n \n \n \n \n \n \n \n \n \n \n \n \nGitHub Sponsors\n \nFund open source developers\n \n \n \n \n \n \n \n \n \n \nThe ReadME Project\n \nGitHub community articles\n \n \n \n \n \n \n \n \n \n \n \n \n \nEnterprise platform\n \nAI-powered developer platform\n \n \n \n \n \n \n Pricing \n \n \n \n \n \nSign up\n \n \n",
-      image: "https://opengraph.githubassets.com/2388498497e355faeecdd0ebc0ae18ac0680ba329b5f7030aa21bc38ddaa6b8b/RoboZoom/knowledge_management",
-      favicon: "https://github.com/fluidicon.png"
-    },
-    {
-      id: "https://creati.ai/ai-tools/sciphi/",
-      title: "SciPhi: Build, Deploy, and Optimize AI Systems | Creati.ai",
-      url: "https://creati.ai/ai-tools/sciphi/",
-      publishedDate: "2024-07-01T00:00:00.000Z",
-      author: "",
-      score: 0.37101393938064575,
-      text: "SciPhi simplifies building, deploying, and optimizing Retrieval-Augmented Generation (RAG) systems, empowering developers to focus on AI innovation. Added on: Social &amp; Email: Platform: SciPhi SciPhi simplifies building, deploying, and optimizing Retrieval-Augmented Generation (RAG) systems, empowering developers to focus on AI innovation. Added on: Social &amp; Email: Platform: What is SciPhi? SciPhi is an open-source platform designed to simplify the building, deploying, and scaling of Retrieval-Augmented Generation (RAG) systems. It provides an end-to-end solution for developers, enabling them to focus on AI innovation without worrying about the underlying infrastructure. With tools for automated knowledge graph extraction, document and user management, and robust observability, SciPhi ensures efficient and optimized RAG system deployment. Who will use SciPhi? Developers AI Engineers Data Scientists Tech Startups Research Institutions How to use the SciPhi? Step1: Visit the SciPhi website. Step2: Sign up for an account or log in. Step3: Access the platform's dashboard. Step4: Follow guides to build and deploy your RAG system. Step5: Use tools for knowledge graph extraction and management. Step6: Optimize and monitor your system using provided observability features. SciPhi's Core Features &amp; Benefits The Core Features of SciPhi End-to-End RAG System Deployment Automated Knowledge Graph Extraction Document and User Management Robust Observability Tools The Benefits of SciPhi Simplifies AI Development Speeds Up Deployment Time Enhances System Optimization Reduces Infrastructure Complexity SciPhi's Main Use Cases &amp; Applications Building RAG Systems for AI Applications Deploying Knowledge Graphs Managing Large Document Repositories Optimizing AI System Performance FAQs of SciPhi SciPhi is an open-source platform designed to simplify building, deploying, and optimizing Retrieval-Augmented Generation (RAG) systems. SciPhi is intended for developers, AI engineers, data scientists, tech startups, and research institutions. Core features include end-to-end RAG system deployment, automated knowledge graph extraction, document and user management, and robust observability tools. Visit the SciPhi website, sign up for an account, and follow the guides to build and deploy your RAG system. SciPhi supports web platforms. SciPhi simplifies AI development, speeds up deployment time, enhances system optimization, and reduces infrastructure complexity. Yes, alternatives include LangChain, LlamaIndex, Haystack, and Flower. SciPhi supports building RAG systems for AI applications, deploying knowledge graphs, managing large document repositories, and optimizing AI system performance. You can reach out to their support team via their support email provided on the website. SciPhi offers both free and paid plans. Details on pricing can be found on their website. SciPhi Company Information Website: https://www.sciphi.ai Company Name: SciPhi Support Email: [ema",
-      image: "https://cdn-image.creati.ai/ai-tools/product-image/sciphi.webp",
-      favicon: "https://cdn-image.creati.ai/image/Creatiai.ico"
-    },
-    {
-      id: "https://helpjuice.com/blog/open-source-knowledge-base",
-      title: "The 12 Best Open Source Knowledge Base Software for 2024",
-      url: "https://helpjuice.com/blog/open-source-knowledge-base",
-      author: "Zeeshan Khan",
-      text: "\n \n \n \n \n At Helpjuice / \n \n #Software &amp; Alternatives\n May 15 2025 \n 11m read \n \n \n \n \n On the hunt for the perfect knowledge base software that\u2019s open source? This post will walk you through the best options for your business. \n \n \n \n \n There\u2019s no denying that a knowledge base can make a major impact on your organization.\xA0 Whether it's to help provide better support to your customers or to enable your employees to find the information they need to do their job, a finely-tuned knowledge base can make all the difference when it comes to how knowledge and information flows through your business. And with plenty of options on the market out there, there\u2019s certainly no shortage of open source knowledge base software. But how can you tell you\u2019re not investing time into installing and learning new software that your team won't use anyway? How can you avoid the time and effort put into an open source option that you later determine to not be a good fit for your needs?\xA0 It\u2019s simple\u2014do a little research beforehand. We know, we know\u2014you don\u2019t have endless time to invest in that kind of thing (what with a business to run and all). That\u2019s why we\u2019ve created a helpful list of the must-consider open source knowledge base software that companies of all niches, industries, and sizes should consider.\xA0 We\u2019re even throwing in a little helpful knowledge that should equip you with the information needed to choose the right software for you\u2014like what knowledge base software is in the first place, the benefits of open source software, and how to address your unique needs as a company to choose the right software for you.\xA0 Want to skip ahead on some of the basics of open-source knowledge base software?\xA0 Be our guest.\xA0 The best open source knowledge base software includes: \n BookStack \n OpenKM \n myBase \n eXo \n PHPKB \n Documize \n DocuWiki \n phpMyFAQ \n MediaWiki \n xWiki \n TWiki \n TiddlyWiki \n What is an Open Source Knowledge Base? Before we dive into which open-source knowledge base software you should consider for your business, we should probably ensure we\u2019re on the same page about what exactly open-source knowledge base software is.\xA0 First things first, let\u2019s start with the term knowledge base. A knowledge base is a central place that allows structured storage of information where users can search for and access this information. \xA0Knowledge base software should be the key tool that helps make this process seamless, simplified, and efficient. Knowledge base software is designed to help you create and manage your knowledge base to the best of your ability. this usually includes setting up the knowledge base architecture, creating and editing documentation, searching, and analyzing your knowledge base, and more. Ideally, this is the irreplaceable piece of the puzzle that operates your entire knowledge management system that helps orchestrate, manage, and optimize the flow of knowledge within your organization.\xA0 That part seems pretty clear, right? Next, we\u2019ll move on to",
-      image: "https://static.helpjuice.com/helpjuice_production/uploads/upload/image/4752/direct/1636499945090-Open%20Source%20Knowledge%20Base%20Software.jpg",
-      favicon: "https://static.helpjuice.com/assets/favicon-32x32-161f2153235b710a8ed7b9233ed6b195936bdb57bf1310e720f7fea79547cf9d.png"
-    }
-  ],
-  costDollars: {
-    total: 0.015,
-    search: {
-      neural: 5e-3
-    },
-    contents: {
-      text: 0.01
-    }
-  }
-};
-
-// src/functions/exa/data/index.ts
-var SEARCH_RESULTS = [
-  exa_search_1748337321991_default,
-  exa_search_1748337331526_default,
-  exa_search_1748337344119_default
-];
-
-// src/functions/exa/mock.ts
-var mock_default = defineFunction29({
-  key: "dxos.org/function/exa-mock",
-  name: "Exa mock",
-  description: "Search the web for information",
-  inputSchema: Schema34.Struct({
-    query: Schema34.String.annotations({
-      description: "The query to search for."
-    })
-  }),
-  outputSchema: Schema34.Unknown,
-  handler: Effect33.fnUntraced(function* ({ data: { query: query2 } }) {
-    const result = SEARCH_RESULTS.reduce((closest, current) => {
-      if (!current.autopromptString) {
-        return closest;
-      }
-      if (!closest) {
-        return current;
-      }
-      const dist1 = levenshteinDistance(query2, current.autopromptString);
-      const dist2 = levenshteinDistance(query2, closest.autopromptString || "");
-      const weight1 = dist1 / Math.max(query2.length, current.autopromptString.length);
-      const weight2 = dist2 / Math.max(query2.length, closest.autopromptString?.length || 0);
-      return weight1 < weight2 ? current : closest;
-    }, null);
-    return result;
-  })
-});
-var levenshteinDistance = (str1, str2) => {
-  const m = str1.length;
-  const n = str2.length;
-  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) {
-    dp[i][0] = i;
-  }
-  for (let j = 0; j <= n; j++) {
-    dp[0][j] = j;
-  }
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] = str1[i - 1] === str2[j - 1] ? dp[i - 1][j - 1] : Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
-    }
-  }
-  return dp[m][n];
-};
-
-// src/functions/exa/index.ts
-var ExaFunctions = {
-  Search: exa_default,
-  Mock: mock_default
-};
-
-// src/toolkits/WebToolkit.ts
-var WebToolkit_exports = {};
-__export(WebToolkit_exports, {
-  WebToolkit: () => WebToolkit,
-  layer: () => layer3
-});
 import * as Tool2 from "@effect/ai/Tool";
-import * as Toolkit4 from "@effect/ai/Toolkit";
-import * as AnthropicTool3 from "@effect/ai-anthropic/AnthropicTool";
-import * as Effect34 from "effect/Effect";
-import * as Schema35 from "effect/Schema";
-var WebToolkit = Toolkit4.make(AnthropicTool3.WebSearch_20250305({}).pipe(), Tool2.make("WebFetch", {
+import * as Toolkit3 from "@effect/ai/Toolkit";
+import * as Effect2 from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+var WebToolkit = Toolkit3.make(AnthropicTool2.WebSearch_20250305({}).pipe(), Tool2.make("WebFetch", {
   parameters: {
-    url: Schema35.String
+    url: Schema2.String
   },
-  success: Schema35.String
+  success: Schema2.String
 }));
-var layer3 = WebToolkit.toLayer({
-  WebFetch: Effect34.fnUntraced(function* ({ url }) {
-    const response = yield* Effect34.promise(() => fetch(url).then((response2) => response2.text()));
+var layer = WebToolkit.toLayer({
+  WebFetch: Effect2.fnUntraced(function* ({ url }) {
+    const response = yield* Effect2.promise(() => fetch(url).then((response2) => response2.text()));
     return response;
   })
 });
 export {
-  AgentFunctions,
-  blueprint_default9 as BrowserBlueprint,
+  AddArtifact,
+  Agent_exports as Agent,
+  blueprint_default as AgentBlueprint,
+  AgentBlueprintHandlers,
+  AgentHandlers,
+  AgentPrompt,
+  AgentRules,
+  blueprint_default11 as AgentWizardBlueprint,
+  AgentWizardHandlers,
+  AgentWorker,
+  blueprint_default9 as AutomationBlueprint,
+  blueprint_default10 as BlueprintManagerBlueprint,
+  BlueprintManagerHandlers,
+  blueprint_default6 as BrowserBlueprint,
   Chat_exports as Chat,
-  blueprint_default10 as DatabaseBlueprint,
-  DatabaseFunctions,
-  blueprint_default2 as DesignBlueprint,
-  blueprint_default3 as DiscordBlueprint,
-  EntityExtractionFunctions,
-  ExaFunctions,
-  blueprint_default5 as LinearBlueprint,
+  ContextAdd,
+  ContextRemove,
+  CreateAgent,
+  blueprint_default7 as DatabaseBlueprint,
+  DatabaseHandlers,
+  Load as DatabaseLoad,
+  Query as DatabaseQuery,
+  DeleteMemory,
+  blueprint_default2 as DiscordBlueprint,
+  DiscordHandlers,
+  EnableBlueprints,
+  FetchMessages,
+  GetContext,
+  blueprint_default3 as LinearBlueprint,
+  LinearHandlers,
   LocalSearchHandler,
   LocalSearchToolkit,
-  blueprint_default as MarkdownBlueprint,
-  MarkdownFunctions,
+  McpServer_exports as McpServer,
+  Memory_exports as Memory,
+  blueprint_default8 as MemoryBlueprint,
+  MemoryHandlers,
+  ObjectCreate,
+  ObjectDelete,
+  ObjectUpdate,
   Plan_exports as Plan,
-  blueprint_default6 as PlanningBlueprint,
-  Project_exports as Project,
-  blueprint_default4 as ProjectBlueprint,
-  ProjectFunctions,
-  blueprint_default7 as ResearchBlueprint,
-  ResearchDataTypes,
-  ResearchGraph_exports as ResearchGraph,
+  blueprint_default4 as PlanningBlueprint,
+  PlanningHandlers,
+  UpdateTasks as PlanningUpdateTasks,
+  Qualifier,
+  QueryBlueprints,
+  QueryMemories,
+  RelationCreate,
+  RelationDelete,
+  SaveMemory,
+  SchemaAdd,
+  SchemaList,
   Subgraph,
-  blueprint_default8 as WebSearchBlueprint,
+  SyncIssues,
+  SyncTriggers,
+  TagAdd,
+  TagRemove,
+  blueprint_default5 as WebSearchBlueprint,
+  Fetch as WebSearchFetch,
+  WebSearchHandlers,
   WebSearchToolkit,
+  WebSearchToolkitOpaque,
   WebToolkit_exports as WebToolkit,
   createExtractionSchema,
   findRelatedSchema,