@dbx-tools/search 0.6.9

package/README.md

@@ -0,0 +1,297 @@
+# @dbx-tools/search
+
+A Meilisearch-style shortcut over Databricks AI Search (Vector Search): a search
+client, agent tools, and an AppKit plugin.
+
+Import this package when an AppKit or Mastra backend needs to search a
+[Databricks AI Search](https://docs.databricks.com/aws/en/ai-search/ai-search)
+index - for autocomplete, docs lookup, RAG retrieval, or a universal search box
+across several indexes. It wraps the low-level SDK
+(`vectorSearchIndexes.queryIndex({ index_name, columns, query_text, query_type,
+num_results, filters_json })` and its columnar response) behind an ergonomic
+client, and ships the agent tools, HTTP routes, and boot config a search UI
+needs - so search is one plugin and, in the simple case, zero config.
+
+**Key features:**
+
+- A small, Meilisearch-shaped client: `client.index("catalog.schema.docs")`,
+  `index.search(query)`, `index.autocomplete(prefix)`, `index.addDocuments(...)`,
+  and `client.universalSearch(query)` to fan a query across many indexes and
+  merge the hits.
+- Hybrid matching by default (semantic similarity fused with BM25 keyword
+  ranking), with `vector` and `keyword` modes when you want one or the other.
+- Agent tools for both Mastra (`searchTool()` etc.) and AppKit agents (through
+  the plugin's `ToolProvider`): `search` and `universal_search` reads, plus the
+  opt-in write tools `add_documents`, `create_index`, and `sync_index`.
+- HTTP routes under `/api/search` a browser search box calls directly:
+  `POST /` (search), `POST /universal` (federated), `GET /indexes` (catalogue),
+  and, when writes are enabled, `POST /documents` (upsert),
+  `POST /index` (create), and `POST /index/sync` (refresh).
+- A `clientConfig()` payload so a UI knows the indexes, default, and page size at
+  boot with no round-trip (read it with `usePluginClientConfig("search")`).
+- Sensible-default config that infers almost everything: name a default index
+  (or set `DATABRICKS_VECTOR_SEARCH_INDEX`) and the columns, page size, mode,
+  aliases, and route path all have defaults you can override when you need to go
+  deeper.
+- OBO throughout: routes wrap in `asUser(req)` and the client resolves the
+  execution-context workspace client, so search runs as the requesting user and
+  Unity Catalog ACLs apply.
+- Filters as plain `{ column: value }` (or `{ column: { ">=": n } }`) compiled to
+  the index `filters_json` for you; the columnar response is unpacked into
+  `{ id, score, fields }` hits.
+- Embedding-model resolution for index creation reuses
+  [`@dbx-tools/model`](../model): a loose name fuzzy-matches the live catalogue,
+  or the best embedding endpoint is chosen automatically.
+- Index lifecycle without the ceremony: `createIndex` / `ensureIndex` (Delta
+  Sync from a source table, self-managed direct-access with a dimension, or a
+  managed direct-access index that embeds a text column - no Delta table or
+  warehouse), `provision` (ensure + seed in one idempotent call), `syncIndex`,
+  `deleteIndex`, `listIndexes`, and `ensureEndpoint` - each inferring the
+  endpoint, embedding model, primary key, and columns from sensible defaults.
+- Wire up a real index on boot with `ensureOnSetup`: the plugin provisions the
+  endpoint + index and seeds documents in the background using the app's SDK
+  auth (env or `DATABRICKS_CONFIG_PROFILE`), so a fresh deployment is searchable
+  with no manual setup.
+- A **Lakebase full-text fallback**: when no Vector Search endpoint is
+  configured but the AppKit `lakebase` plugin is registered, search transparently
+  runs on a Postgres `tsvector` index instead - same `provision` / `search` /
+  `add_documents` calls, same `{ id, score, fields }` hits, so tools, routes, and
+  the UI can't tell which backend answered. No endpoint, no embeddings, no Delta
+  table - just a table the plugin creates and seeds on boot.
+
+## Why Use This Over Native AppKit
+
+AppKit exposes Vector Search as a resource type and a low-level serving surface,
+but nothing that makes a search box or an agent tool a one-liner. Use this
+package when you want search to be a drop-in: the friendly client hides the
+verbose `queryIndex` request and columnar response, the plugin gives agents a
+`search` tool and a browser a `POST /api/search` route in one registration,
+universal search fans across indexes, and the config infers everything from a
+single index name. Reach for the raw SDK when you need index lifecycle
+operations this package does not wrap.
+
+## Quick Start
+
+```ts
+import { createApp, server } from "@databricks/appkit";
+import { plugin as searchPlugin, tool as searchToolModule } from "@dbx-tools/search";
+import { agents, plugin as mastraPlugin } from "@dbx-tools/appkit-mastra";
+
+const support = agents.createAgent({
+  instructions: "Answer from the docs; use `search` to find them.",
+  tools: () => ({ search: searchToolModule.searchTool() }),
+});
+
+await createApp({
+  plugins: [
+    server(),
+    // zero-config: reads DATABRICKS_VECTOR_SEARCH_INDEX / SEARCH_INDEX
+    searchPlugin.search(),
+    mastraPlugin.mastra({ agents: support }),
+  ],
+});
+```
+
+Going deeper:
+
+```ts
+searchPlugin.search({
+  index: "main.support.docs",
+  indexes: [
+    "main.support.docs",
+    { name: "main.catalog.products", alias: "products", columns: ["name", "sku", "price"] },
+  ],
+  columns: ["title", "url", "body"],
+  mode: "hybrid",
+  pageSize: 10,
+  allowWrite: false,
+});
+```
+
+## Use The Client Directly
+
+```ts
+import { createSearchClient } from "@dbx-tools/search";
+
+const client = createSearchClient();
+const docs = client.index("main.support.docs");
+
+const { hits } = await docs.search("reset my password", { limit: 5 });
+const suggestions = await docs.autocomplete("rese");
+const everywhere = await client.universalSearch("invoice error 402");
+
+await docs.addDocuments([{ id: "42", title: "Reset", body: "…" }]);
+```
+
+## Manage Indexes
+
+Create and maintain indexes with the same infer-everything ergonomics. A Delta
+Sync index computes embeddings from a source Delta table and stays synced; the
+embedding model, endpoint, primary key (`id`), and text column
+(`text`/`content`/`body`) are all inferred when omitted.
+
+```ts
+const client = createSearchClient();
+
+// Ensure the Vector Search endpoint exists (creates a STANDARD one if not).
+await client.ensureEndpoint("my-vs-endpoint", { wait: true });
+
+// Delta Sync index from a Delta table (embeddings computed by Databricks).
+await client.ensureIndex("main.support.docs", {
+  endpoint: "my-vs-endpoint",
+  sourceTable: "main.support.docs_source",
+  // embeddingModel / primaryKey / embeddingSourceColumn inferred when omitted
+});
+
+// Trigger a sync, then later delete.
+await client.syncIndex("main.support.docs");
+await client.deleteIndex("main.support.docs");
+
+// Managed direct-access index (the lightest REAL index): Databricks embeds a
+// text column on write AND query, so no Delta table, no warehouse, no vectors.
+await client.createIndex("main.support.docs", {
+  endpoint: "my-vs-endpoint",
+  // managed by default when no embeddingDimension is given
+});
+await client
+  .index("main.support.docs")
+  .addDocuments([{ id: "1", text: "AI Search finds the most relevant documents for a query." }]);
+
+// Self-managed direct-access index you write vectors to yourself.
+await client.createIndex("main.support.vectors", { embeddingDimension: 1024 });
+await client.index("main.support.vectors").addDocuments([{ id: "1", embedding: [/* … */] }]);
+
+// One call to make an index real AND seeded (idempotent - safe every boot).
+await client.provision("main.support.docs", {
+  endpoint: "my-vs-endpoint",
+  seed: [{ id: "1", text: "Databricks AI Search overview", url: "https://…" }],
+});
+```
+
+The `SearchIndex` handle mirrors these: `index.ensure(opts)`, `index.sync()`,
+`index.delete()`, `index.info()`.
+
+When the plugin's write surface is on (`search({ allowWrite: true })` or
+`SEARCH_WRITE=true`), agents get the same lifecycle as tools: `create_index`
+provisions an index with everything inferred (pass a `sourceTable` for the
+common Delta Sync case, or an `embeddingDimension` for a direct-access index),
+and `sync_index` refreshes a Delta Sync index from its source table. They are
+gated because they change infrastructure, so grant them only where a caller
+should be able to set up or refresh indexes.
+
+### Provision a real index on boot
+
+`ensureOnSetup` makes the plugin wire up a real index when the app starts, using
+the boot-time SDK auth (env vars or a `DATABRICKS_CONFIG_PROFILE`). It ensures
+the endpoint + index exist and seeds documents only when the index is empty, all
+in the background so a slow first-time endpoint build never blocks the server.
+The default is a managed direct-access index, so the seed rows are plain
+objects and search-by-text works immediately - no Delta table, no warehouse.
+
+```ts
+search({
+  index: "main.support.docs",
+  endpoint: "my-vs-endpoint",
+  ensureOnSetup: {
+    embeddingModel: "databricks-gte-large-en", // optional; best embedding endpoint otherwise
+    documents: [
+      { id: "1", title: "Overview", text: "AI Search finds relevant docs.", url: "https://…" },
+      { id: "2", title: "Indexes", text: "Delta Sync vs. direct access." },
+    ],
+    // schema inferred from the first row; primaryKey/textColumn default to id/text
+  },
+});
+```
+
+Idempotent: later boots see the endpoint, index, and rows already present and do
+nothing. Point `ensureOnSetup.sourceTable` at a Delta table to provision a Delta
+Sync index instead of a managed direct-access one.
+
+### Lakebase full-text fallback
+
+When you have **no** Vector Search endpoint configured but the AppKit `lakebase`
+plugin is registered, the plugin transparently falls back to a Postgres
+full-text index. It provisions one table per index (a generated `tsvector`
+column with a GIN index), seeds the same `ensureOnSetup.documents`, and answers
+queries with `websearch_to_tsquery` + `ts_rank`. The pool is built from the
+`lakebase` plugin's service-principal config exactly like
+[`@dbx-tools/appkit-mastra`](../appkit-mastra) builds its memory pool - no auth
+is re-implemented.
+
+The point is parity: the client returns the identical `SearchResult` /
+`SearchHit` (`{ id, score, fields }`) / `UpsertResult` shapes, so the agent
+tools, the `/api/search` routes, and the React search box behave the same
+whichever backend is active. Register `lakebase()`, omit `endpoint`, and search
+works with no Vector Search infrastructure:
+
+```ts
+import { createApp, lakebase } from "@databricks/appkit";
+import { plugin as searchPlugin } from "@dbx-tools/search";
+
+const { search } = searchPlugin;
+
+createApp({
+  plugins: [
+    lakebase(), // register it and search uses Postgres full-text
+    search({
+      // no `endpoint` -> Lakebase full-text fallback
+      index: "docs",
+      ensureOnSetup: {
+        documents: [{ id: "1", title: "Overview", text: "Search over Postgres full-text." }],
+      },
+    }),
+  ],
+});
+```
+
+Selection is automatic and logged at boot (`backend: "vector-search"` vs
+`"lakebase"`). Configure an `endpoint` and Vector Search wins; drop it and the
+Lakebase fallback takes over.
+
+## Configuration
+
+All fields are optional. Precedence is plugin config, then environment, then a
+default.
+
+| Config           | Environment                                      | Default                 | Purpose                                                                                    |
+| ---------------- | ------------------------------------------------ | ----------------------- | ------------------------------------------------------------------------------------------ |
+| `index`          | `SEARCH_INDEX`, `DATABRICKS_VECTOR_SEARCH_INDEX` | –                       | Default index (name or alias).                                                             |
+| `indexes`        | –                                                | `[index]`               | Indexes known for aliases, universal search, and the UI.                                   |
+| `endpoint`       | `SEARCH_ENDPOINT`                                | –                       | Vector Search endpoint (only needed to create an index).                                   |
+| `columns`        | `SEARCH_COLUMNS`                                 | index's columns         | Default columns per hit.                                                                   |
+| `pageSize`       | `SEARCH_PAGE_SIZE`                               | `10`                    | Default hits per search.                                                                   |
+| `mode`           | `SEARCH_MODE`                                    | `hybrid`                | `hybrid` / `vector` / `keyword`.                                                           |
+| `embeddingModel` | `SEARCH_EMBEDDING_MODEL`                         | best embedding endpoint | Embedding endpoint for index creation.                                                     |
+| `timeoutMs`      | `SEARCH_TIMEOUT_MS`                              | `30000`                 | Per-call timeout.                                                                          |
+| `allowWrite`     | `SEARCH_WRITE`                                   | `false`                 | Enable the write tools (`add_documents` / `create_index` / `sync_index`) and their routes. |
+| `ensureOnSetup`  | –                                                | –                       | Provision the endpoint + index and seed documents at boot (background).                    |
+
+## Modules
+
+- `client` - `SearchClient`, `SearchIndex`, `createSearchClient`, the search
+  methods, and the index lifecycle (`createIndex` / `ensureIndex` / `syncIndex`
+  / `deleteIndex` / `listIndexes` / `ensureEndpoint`), plus the `SearchOptions` /
+  `UniversalSearchOptions` / `IndexInfo` / `CreateIndexOptions` /
+  `EnsureEndpointOptions` types.
+- `plugin` - `SearchPlugin` and the `search()` factory (`ToolProvider`,
+  routes, `clientConfig`, `exports`).
+- `tool` - the `searchTool()`, `universalSearchTool()`, `addDocumentsTool()`,
+  `createIndexTool()`, and `syncIndexTool()` Mastra factories.
+- `index-tools` - `toCreateIndexOptions`, the shared mapping from the
+  `create_index` wire request onto `SearchClient.createIndex` options (used by
+  both the Mastra tool and the plugin route).
+- `config` - `resolveSearchConfig`, `resolveIndexName`, `SEARCH_CONFIG_SCHEMA`,
+  the config env constants, and the `SearchPluginConfig` /
+  `ResolvedSearchConfig` types.
+- `query` - `toQueryType`, `compileFilter`, `toHits`, `toRequestColumns`,
+  `toDocumentArray` (contract ↔ serving-API translation).
+- `lakebase` - `LakebaseSearchBackend`, the Postgres full-text FALLBACK used
+  when no Vector Search endpoint is configured (provision + seed + `tsvector`
+  search, same hit shape as Vector Search).
+- `runtime` - `getSearchRuntime` / `resetSearchRuntime` (the shared client).
+- `schema` - the tool descriptions and re-exported request schemas.
+
+Browser-safe schemas live in
+[`@dbx-tools/shared-search`](../../shared/search); the React search box
+lives in [`@dbx-tools/ui-search`](../../ui/search). Model resolution reuses
+[`@dbx-tools/model`](../model).

package/index.ts

@@ -0,0 +1,28 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+export * as client from "./src/client.ts";
+export * as config from "./src/config.ts";
+export * as indexTools from "./src/index-tools.ts";
+export * as lakebase from "./src/lakebase.ts";
+export * as plugin from "./src/plugin.ts";
+export * as query from "./src/query.ts";
+export * as runtime from "./src/runtime.ts";
+export * as schema from "./src/schema.ts";
+export * as tool from "./src/tool.ts";
+export { SearchIndex, SearchClient, createSearchClient } from "./src/client.ts";
+export type { SearchOptions, UniversalSearchOptions, IndexInfo, CreateIndexOptions, EnsureEndpointOptions, ProvisionOptions } from "./src/client.ts";
+export { INDEX_ENV, DATABRICKS_INDEX_ENV, ENDPOINT_ENV, DEFAULT_MODE, DEFAULT_PAGE_SIZE, DEFAULT_TIMEOUT_MS, DEFAULT_BASE_PATH, SEARCH_CONFIG_SCHEMA, defaultAlias, resolveSearchConfig, resolveIndexName, indexConfigFor } from "./src/config.ts";
+export type { SearchIndexConfig, SearchPluginConfig, EnsureOnSetupConfig, ResolvedIndexConfig, ResolvedSearchConfig } from "./src/config.ts";
+export { toCreateIndexOptions } from "./src/index-tools.ts";
+export { LakebaseSearchBackend } from "./src/lakebase.ts";
+export type { LakebaseSearchOptions, LakebaseProvisionOptions } from "./src/lakebase.ts";
+export { SearchPlugin, search } from "./src/plugin.ts";
+export { toQueryType, compileFilter, toHits, toRequestColumns, toDocumentArray } from "./src/query.ts";
+export type { QueryResponseLike } from "./src/query.ts";
+export { getSearchRuntime, resetSearchRuntime } from "./src/runtime.ts";
+export type { SearchRuntimeOptions, SearchRuntime } from "./src/runtime.ts";
+export { SEARCH_TOOL_DESCRIPTION, UNIVERSAL_SEARCH_TOOL_DESCRIPTION, ADD_DOCUMENTS_TOOL_DESCRIPTION, CREATE_INDEX_TOOL_DESCRIPTION, SYNC_INDEX_TOOL_DESCRIPTION, searchToolSchema, universalSearchToolSchema, searchResultSchema, createIndexToolSchema, indexInfoSchema, syncIndexToolSchema } from "./src/schema.ts";
+export { searchTool, universalSearchTool, addDocumentsTool, createIndexTool, syncIndexTool } from "./src/tool.ts";
+export type { SearchToolOptions } from "./src/tool.ts";

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+export * as client from "./src/client.ts";
+export * as config from "./src/config.ts";
+export * as indexTools from "./src/index-tools.ts";
+export * as lakebase from "./src/lakebase.ts";
+export * as plugin from "./src/plugin.ts";
+export * as query from "./src/query.ts";
+export * as runtime from "./src/runtime.ts";
+export * as schema from "./src/schema.ts";
+export * as tool from "./src/tool.ts";
+export { SearchIndex, SearchClient, createSearchClient } from "./src/client.ts";
+export type { SearchOptions, UniversalSearchOptions, IndexInfo, CreateIndexOptions, EnsureEndpointOptions, ProvisionOptions } from "./src/client.ts";
+export { INDEX_ENV, DATABRICKS_INDEX_ENV, ENDPOINT_ENV, DEFAULT_MODE, DEFAULT_PAGE_SIZE, DEFAULT_TIMEOUT_MS, DEFAULT_BASE_PATH, SEARCH_CONFIG_SCHEMA, defaultAlias, resolveSearchConfig, resolveIndexName, indexConfigFor } from "./src/config.ts";
+export type { SearchIndexConfig, SearchPluginConfig, EnsureOnSetupConfig, ResolvedIndexConfig, ResolvedSearchConfig } from "./src/config.ts";
+export { toCreateIndexOptions } from "./src/index-tools.ts";
+export { LakebaseSearchBackend } from "./src/lakebase.ts";
+export type { LakebaseSearchOptions, LakebaseProvisionOptions } from "./src/lakebase.ts";
+export { SearchPlugin, search } from "./src/plugin.ts";
+export { toQueryType, compileFilter, toHits, toRequestColumns, toDocumentArray } from "./src/query.ts";
+export type { QueryResponseLike } from "./src/query.ts";
+export { getSearchRuntime, resetSearchRuntime } from "./src/runtime.ts";
+export type { SearchRuntimeOptions, SearchRuntime } from "./src/runtime.ts";
+export { SEARCH_TOOL_DESCRIPTION, UNIVERSAL_SEARCH_TOOL_DESCRIPTION, ADD_DOCUMENTS_TOOL_DESCRIPTION, CREATE_INDEX_TOOL_DESCRIPTION, SYNC_INDEX_TOOL_DESCRIPTION, searchToolSchema, universalSearchToolSchema, searchResultSchema, createIndexToolSchema, indexInfoSchema, syncIndexToolSchema } from "./src/schema.ts";
+export { searchTool, universalSearchTool, addDocumentsTool, createIndexTool, syncIndexTool } from "./src/tool.ts";
+export type { SearchToolOptions } from "./src/tool.ts";

package/lib/index.js

@@ -0,0 +1,22 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as client from "./src/client.js";
+export * as config from "./src/config.js";
+export * as indexTools from "./src/index-tools.js";
+export * as lakebase from "./src/lakebase.js";
+export * as plugin from "./src/plugin.js";
+export * as query from "./src/query.js";
+export * as runtime from "./src/runtime.js";
+export * as schema from "./src/schema.js";
+export * as tool from "./src/tool.js";
+export { SearchIndex, SearchClient, createSearchClient } from "./src/client.js";
+export { INDEX_ENV, DATABRICKS_INDEX_ENV, ENDPOINT_ENV, DEFAULT_MODE, DEFAULT_PAGE_SIZE, DEFAULT_TIMEOUT_MS, DEFAULT_BASE_PATH, SEARCH_CONFIG_SCHEMA, defaultAlias, resolveSearchConfig, resolveIndexName, indexConfigFor } from "./src/config.js";
+export { toCreateIndexOptions } from "./src/index-tools.js";
+export { LakebaseSearchBackend } from "./src/lakebase.js";
+export { SearchPlugin, search } from "./src/plugin.js";
+export { toQueryType, compileFilter, toHits, toRequestColumns, toDocumentArray } from "./src/query.js";
+export { getSearchRuntime, resetSearchRuntime } from "./src/runtime.js";
+export { SEARCH_TOOL_DESCRIPTION, UNIVERSAL_SEARCH_TOOL_DESCRIPTION, ADD_DOCUMENTS_TOOL_DESCRIPTION, CREATE_INDEX_TOOL_DESCRIPTION, SYNC_INDEX_TOOL_DESCRIPTION, searchToolSchema, universalSearchToolSchema, searchResultSchema, createIndexToolSchema, indexInfoSchema, syncIndexToolSchema } from "./src/schema.js";
+export { searchTool, universalSearchTool, addDocumentsTool, createIndexTool, syncIndexTool } from "./src/tool.js";
+//# sourceMappingURL=data:application/json;base64,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