feat: add workspace-level semantic search across v2 notebooks

Author: claude

openapi.yaml

@@ -705,6 +705,36 @@ paths:
                     type: array
                     items:
                       $ref: '#/components/schemas/Notebook'
+
+  /api/v2/workspaces/{workspaceId}/search:
+    post:
+      summary: Workspace semantic search across notebooks
+      operationId: workspaceSearchV2
+      tags: [notebooks-v2]
+      x-auth-scope: read
+      parameters:
+        - $ref: '#/components/parameters/WorkspaceId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required: [query]
+              properties:
+                query:
+                  type: string
+                limit:
+                  type: integer
+                  minimum: 1
+                  maximum: 50
+                threshold:
+                  type: number
+                  minimum: 0
+                  maximum: 1
+      responses:
+        '200':
+          description: Workspace-scoped search results with notebook attribution
     post:
       summary: Create notebook
       operationId: createNotebookV2

src/index.ts

@@ -14,6 +14,7 @@ import { telemetry } from './routes/telemetry'
 import { chat } from './routes/chat'
 import { notebooksV2 } from './routes/notebooks-v2'
 import { notebooksV2Manage } from './routes/notebooks-v2-manage'
+import { workspacesV2 } from './routes/workspaces-v2'
 import { handleIngestion } from './queue'
 
 const app = new Hono<{ Bindings: Env; Variables: AppVariables }>()
@@ -82,6 +83,7 @@ app.route('/api/conversations', conversations)
 // --- Notebook v2: workspace-scoped source intelligence ---
 app.use('/api/v2/workspaces/*', requireAuth('read'))
 app.use('/api/v2/workspaces/*', rateLimit({ maxRequests: 30, windowSeconds: 60 }))
+app.route('/api/v2/workspaces/:workspaceId', workspacesV2)
 app.route('/api/v2/workspaces/:workspaceId/notebooks', notebooksV2)
 app.route('/api/v2/workspaces/:workspaceId/notebooks', notebooksV2Manage)
 

src/lib/vectorize.ts

@@ -19,7 +19,7 @@ import type {
 
 const TEXT_PREVIEW_LENGTH = 500
 
-export class VectorStore {
+export class VectorStore {
   private vectorize: VectorizeIndex
   private kv: KVNamespace
 
@@ -147,6 +147,72 @@ export class VectorStore {
       })
     )
   }
+
+  /**
+   * Workspace-style semantic search across multiple notebook IDs.
+   * Filters results in application layer using Vectorize metadata pointers.
+   */
+  async searchByNotebookIds(
+    queryVector: number[],
+    notebookIds: string[],
+    limit: number = 10,
+    scoreThreshold: number = 0.3,
+    options: { hydrateFullText?: boolean } = {}
+  ): Promise<Array<SearchResult & { notebook_id?: string }>> {
+    const { hydrateFullText = true } = options
+    if (notebookIds.length === 0) return []
+
+    const notebookIdSet = new Set(notebookIds)
+    const results = await this.vectorize.query(queryVector, {
+      topK: Math.max(limit * 10, 100),
+      returnMetadata: 'all',
+    })
+
+    if (!results.matches || results.matches.length === 0) return []
+
+    const filtered = results.matches
+      .filter((m) => {
+        const meta = m.metadata as unknown as ConversationMetadata
+        return !!meta?.notebook_id && notebookIdSet.has(meta.notebook_id)
+      })
+      .filter((m) => (m.score ?? 0) >= scoreThreshold)
+      .slice(0, limit)
+
+    if (!hydrateFullText) {
+      return filtered.map((match) => {
+        const meta = match.metadata as unknown as ConversationMetadata
+        const convId = meta?.id ?? match.id
+        return {
+          id: convId,
+          title: meta?.title ?? 'Untitled',
+          text: meta?.text_preview ?? '',
+          create_time: meta?.create_time ?? 0,
+          score: match.score ?? 0,
+          notebook_id: meta?.notebook_id,
+        }
+      })
+    }
+
+    return Promise.all(
+      filtered.map(async (match) => {
+        const meta = match.metadata as unknown as ConversationMetadata
+        const convId = meta?.id ?? match.id
+        const fullRaw = await this.kv.get(`conv:${convId}`)
+        const full: ConversationRecord | null = fullRaw
+          ? JSON.parse(fullRaw)
+          : null
+
+        return {
+          id: convId,
+          title: full?.title ?? meta?.title ?? 'Untitled',
+          text: full?.text ?? meta?.text_preview ?? '',
+          create_time: full?.create_time ?? meta?.create_time ?? 0,
+          score: match.score ?? 0,
+          notebook_id: full?.notebook_id ?? meta?.notebook_id,
+        }
+      })
+    )
+  }
 
   /**
    * Get a single conversation by ID from KV.

src/routes/workspaces-v2.ts

@@ -0,0 +1,70 @@
+import { Hono } from 'hono'
+import type { Env } from '../lib/types'
+import { generateQueryEmbedding } from '../lib/embeddings'
+import { VectorStore } from '../lib/vectorize'
+
+const workspacesV2 = new Hono<{ Bindings: Env }>()
+
+function requireParam(value: string | undefined, name: string): string {
+  if (!value) throw new Error(`Missing path param: ${name}`)
+  return value
+}
+
+workspacesV2.post('/search', async (c) => {
+  const workspaceId = requireParam(c.req.param('workspaceId'), 'workspaceId')
+  const body = await c.req.json<{
+    query: string
+    limit?: number
+    threshold?: number
+  }>()
+
+  if (!body.query?.trim()) {
+    return c.json({ error: 'query is required' }, 400)
+  }
+  if (!c.env.DB) {
+    return c.json({ error: 'D1 DB binding is required for workspace search' }, 501)
+  }
+
+  const notebookRows = await c.env.DB
+    .prepare(
+      `SELECT id, title
+       FROM notebooks
+       WHERE workspace_id = ? AND deleted_at IS NULL`
+    )
+    .bind(workspaceId)
+    .all<{ id: string; title: string }>()
+
+  const notebookIds = notebookRows.results.map((n) => n.id)
+  const notebookTitleById = new Map(notebookRows.results.map((n) => [n.id, n.title]))
+
+  if (notebookIds.length === 0) {
+    return c.json({ query: body.query, count: 0, results: [] })
+  }
+
+  const queryVector = await generateQueryEmbedding(body.query, c.env)
+  const store = new VectorStore(c.env)
+  const limit = Math.min(Math.max(body.limit ?? 10, 1), 50)
+  const threshold = body.threshold ?? 0
+
+  const hits = await store.searchByNotebookIds(
+    queryVector,
+    notebookIds,
+    limit,
+    threshold,
+    { hydrateFullText: true }
+  )
+
+  return c.json({
+    query: body.query,
+    count: hits.length,
+    results: hits.map((hit) => ({
+      ...hit,
+      notebook_id: hit.notebook_id ?? null,
+      notebook_title: hit.notebook_id
+        ? (notebookTitleById.get(hit.notebook_id) ?? null)
+        : null,
+    })),
+  })
+})
+
+export { workspacesV2 }