vybekiit 0.7.29 → 0.7.33

package/dist/global-skills/neon-functions/references/native-binaries.md

@@ -0,0 +1,188 @@
+# Shipping native binaries with a Function
+
+The default deploy bundles `source` into a single `index.mjs` with esbuild. A compiled binary cannot be inlined into that file, so it has to ship as a separate file in the deploy archive. There are three ways to put it there. Pick by what the binary is:
+
+| The binary is                                                                              | Use                                                            |
+| ------------------------------------------------------------------------------------------ | -------------------------------------------------------------- |
+| An npm package backed by a Node-API addon (`sharp`, most `@napi-rs/*` packages)             | [`externalPackages`](#externalpackages-npm-packages-with-a-node-addon) |
+| A file your own build step produces: a `.node` addon, a `.so`, a `.wasm`, model weights    | [`bundler: "none"`](#bundler-none-ship-a-prebuilt-directory) or a [custom `bundler`](#custom-bundler-return-the-file-map) |
+| A standalone executable you spawn (`ffmpeg`, a Go or Rust CLI)                              | A custom `bundler` or `"none"`, plus [a copy to `/run` at startup](#standalone-executables) |
+
+The examples use top-level `functions`, which needs `neon` CLI 4.20 or newer and `@neon/config` 1.6 or newer.
+
+## The runtime a binary lands on
+
+- **linux, arm64, glibc**, Node.js 24. A binary built for macOS or x64 cannot load there.
+- The archive is extracted to `/opt/function`, a read-only filesystem. `import.meta.url` in the root `index.mjs` points there, so `new URL("./bin/tool", import.meta.url)` resolves to `/opt/function/bin/tool`.
+- **Every file arrives with mode `644`.** Unix permission bits in the zip are dropped on extraction, and `chmod` in place fails with `EROFS`. A `.node` or `.so` loads fine (it is `dlopen`ed, not executed). Spawning a file from `/opt/function` fails with `EACCES`.
+- `/tmp` is writable and mounted `noexec`: a copied binary still fails with `EACCES` after `chmod 755`.
+- `/run` is a writable tmpfs that allows exec (about 990 MiB, backed by the function's 2048 MiB of memory).
+
+The filesystem layout is observed behavior, not documented by Neon. Re-check it if spawning starts failing.
+
+## `externalPackages`: npm packages with a Node addon
+
+```typescript
+// neon.ts
+import { defineConfig } from "@neon/config/v1";
+
+export default defineConfig({
+  functions: {
+    resize: {
+      name: "Resize",
+      source: "./src/resize.ts",
+      externalPackages: ["sharp"],
+    },
+  },
+});
+```
+
+esbuild leaves `import sharp from "sharp"` unresolved. At deploy, the CLI installs the version of `sharp` from your project with `npm install --cpu=arm64 --os=linux --libc=glibc --ignore-scripts` into a temp directory, traces the files it reaches with `@vercel/nft`, and copies them into the archive under `node_modules/` with the tree layout intact. Only the installed version is read from your `node_modules`; the shipped files come from the temp install, and your `node_modules` is not modified.
+
+The deploy fails with a named error when:
+
+- the package is not installed in your project (no version to pin)
+- the declared package itself does not install for linux-arm64 glibc (`EBADPLATFORM`)
+- a staged `.node` or `.so` is not an AArch64 ELF binary
+- `npm` is not on `PATH`
+- the archive exceeds the [size limits](#size-limits)
+
+It does not fail when a platform-specific optional dependency is silently skipped, or when a package that compiles from source at install time ships no binary (the staging install runs with `--ignore-scripts`). Those deploy and then fail at invoke. Use packages that publish a linux-arm64 glibc prebuild (`sharp` does), and invoke the deployed function once to confirm the addon loads.
+
+A deploy and `neon dev` print an advisory warning for any bundled package that carries native code and is not declared. A package with a working JavaScript fallback (`ws` with `bufferutil`) triggers it too and needs no change. Do not silence it with `{ name, includeFiles: false }`: that externalizes the package and ships nothing, so a reached import throws `Cannot find module` on every invoke. `includeFiles: false` is only for an import the function never evaluates.
+
+Under `neon dev`, the package is only kept out of the bundle and resolves from your own `node_modules` for your host.
+
+Pros: one line in `neon.ts`; the target-platform install, file tracing, arch check, and size check are automatic; local dev uses your host build.
+
+Cons: only for npm packages that publish a linux-arm64 glibc prebuild; transitive pins, overrides, and patches from your lockfile are not carried into the staged install; esbuild bundler only (`externalPackages` with `bundler: "none"` or a function fails validation).
+
+## `bundler: "none"`: ship a prebuilt directory
+
+Run your own build, then point `source` at its output. The directory root must contain `index.mjs` or `index.js`. Everything else in the directory ships as-is:
+
+```text
+dist/fn/
+  index.mjs        # built by your step, reads ./native/addon.node
+  native/addon.node
+```
+
+```typescript
+// neon.ts
+import { defineConfig } from "@neon/config/v1";
+
+export default defineConfig({
+  functions: {
+    api: { name: "API", source: "./dist/fn", bundler: "none" },
+  },
+});
+```
+
+```bash
+npm run build:fn && neon deploy --env .env.local
+neon functions deploy api --src dist/fn --no-bundle   # same thing, without neon.ts
+```
+
+`neon deploy` does not run your build step. Run it first, or use a [custom `bundler`](#custom-bundler-return-the-file-map) to keep the build inside `neon deploy`.
+
+Pros: works with any build tool or framework output (`.mastra/output` is the common one); full control over the archive layout.
+
+Cons: no architecture check, so a binary built for your laptop deploys and then fails at invoke; the build step is yours to keep in sync with `neon deploy`; TypeScript cannot ship unbundled.
+
+## Custom `bundler`: return the file map
+
+An inline function in `neon.ts` returns archive paths mapped to bytes. `neon deploy` zips the map, and `neon dev` serves the same map locally:
+
+```typescript
+// neon.ts
+import { readFile } from "node:fs/promises";
+import { build } from "esbuild";
+import { defineConfig } from "@neon/config/v1";
+
+export default defineConfig({
+  functions: {
+    transcode: {
+      name: "Transcode",
+      source: "./src/transcode.ts",
+      bundler: async (fn) => {
+        const out = await build({
+          entryPoints: [fn.source],
+          bundle: true,
+          platform: "node",
+          format: "esm",
+          write: false,
+          outfile: "index.mjs",
+          // CommonJS dependencies call require(); ESM output has none in scope.
+          banner: {
+            js: "import{createRequire}from'module';const require=createRequire(import.meta.url);",
+          },
+        });
+        return {
+          "index.mjs": out.outputFiles[0].contents,
+          "bin/ffmpeg": new Uint8Array(
+            await readFile(new URL("./vendor/linux-arm64/ffmpeg", import.meta.url)),
+          ),
+        };
+      },
+    },
+  },
+});
+```
+
+`esbuild` must be a dependency of your project. The map needs `index.mjs` or `index.js` at the root.
+
+Pros: the build lives in `neon.ts`, so `neon deploy` and `neon dev` always build the same thing; any file from anywhere can go in the archive.
+
+Cons: no architecture check; `externalPackages` cannot be combined with it, so an npm addon has to be copied into the map by hand, with its `node_modules/` layout.
+
+## Standalone executables
+
+Ship the executable with a custom `bundler` or `bundler: "none"`, then copy it to `/run` and mark it executable once per isolate:
+
+```typescript
+// src/transcode.ts
+import { execFile } from "node:child_process";
+import { chmod, copyFile, mkdir } from "node:fs/promises";
+import { promisify } from "node:util";
+
+const run = promisify(execFile);
+
+let ffmpeg: Promise<string> | undefined;
+function ffmpegPath(): Promise<string> {
+  if (process.env.FFMPEG_PATH) return Promise.resolve(process.env.FFMPEG_PATH);
+  ffmpeg ??= (async () => {
+    await mkdir("/run/bin", { recursive: true });
+    await copyFile(new URL("./bin/ffmpeg", import.meta.url), "/run/bin/ffmpeg");
+    await chmod("/run/bin/ffmpeg", 0o755);
+    return "/run/bin/ffmpeg";
+  })();
+  return ffmpeg;
+}
+
+export default {
+  async fetch() {
+    const { stdout } = await run(await ffmpegPath(), ["-version"]);
+    return new Response(stdout);
+  },
+};
+```
+
+`neon dev` runs this code on your machine, where `/run` may not exist and a linux-arm64 binary cannot execute. Point it at a host install from the shell, and leave `FFMPEG_PATH` out of the function's deployed `env`:
+
+```bash
+FFMPEG_PATH="$(command -v ffmpeg)" neon dev
+```
+
+The binary must be statically linked, or its shared libraries must exist in the runtime image. The copy costs memory: `/run` is RAM-backed and counts against the function's 2048 MiB.
+
+## Size limits
+
+`bundler: "none"`, a custom `bundler`, and `externalPackages` staging check the archive before upload:
+
+| Limit                    | Value   |
+| ------------------------ | ------- |
+| Compressed zip           | 10 MiB  |
+| Total uncompressed bytes | 64 MiB  |
+| Files in the archive     | 4,096   |
+
+Exceeding one fails the deploy. The byte-limit errors list the four largest files. Check an executable's size before building around it: a single static binary can use most of the 64 MiB.

package/dist/global-skills/neon-object-storage/SKILL.md

@@ -15,6 +15,7 @@ description: >-
 metadata:
   parent: neon
   source: https://github.com/neondatabase/agent-skills/tree/main/skills/neon-object-storage
+disable-model-invocation: true
 ---
 
 **FIRST**: Use the parent `neon` skill for a Neon overview, getting started with Neon, Neon development best practices, and more.

package/dist/global-skills/neon-postgres/SKILL.md

@@ -13,6 +13,7 @@ description: >-
 metadata:
   parent: neon
   source: https://github.com/neondatabase/agent-skills/tree/main/skills/neon-postgres
+disable-model-invocation: true
 ---
 
 **FIRST**: Use the parent `neon` skill for a Neon overview, getting started with Neon, Neon development best practices, and more.
@@ -257,7 +258,7 @@ Link: https://neon.com/docs/guides/logical-replication-guide.md
 
 Use Lakebase Search for semantic, full-text, and hybrid search:
 
-- For semantic search, read [Vector search](references/vector-search.md).
+- For semantic search, including generating embeddings with the Neon AI Gateway, read [Vector search](references/vector-search.md).
 - For full-text search with BM25 ranking, read [Full-text search](references/full-text-search.md).
 - For combining semantic and lexical results, read [Hybrid search](references/hybrid-search.md).
 - For managing any of the above through Drizzle ORM, read [Managing Lakebase Search with Drizzle](references/lakebase-search-drizzle.md).

package/dist/global-skills/neon-postgres/references/full-text-search.md

@@ -45,18 +45,24 @@ After a large bulk load, run `VACUUM` to refresh the statistics used by BM25 sco
 `to_bm25query` binds the query `tsvector` to the BM25 index whose corpus statistics should be used. The `<@>` operator returns a negative BM25 score, so lower (more negative) values are more relevant and must sort ascending:
 
 ```sql
-SELECT
-  id,
-  title,
-  body_tsv <@> to_bm25query(
-    to_tsvector('english', $1),
-    'documents_body_bm25'::regclass
-  ) AS score
-FROM documents
+SELECT id, title, score
+FROM (
+  SELECT
+    id,
+    title,
+    body_tsv <@> to_bm25query(
+      to_tsvector('english', $1),
+      'documents_body_bm25'::regclass
+    ) AS score
+  FROM documents
+) AS keyword_scored
+WHERE score < 0
 ORDER BY score
 LIMIT $2;
 ```
 
+Scalar BM25 scoring returns zero for documents containing none of the query terms. Filter `score < 0` before `ORDER BY` and `LIMIT` so keyword results exclude non-matches under both sequential and index plans. Partial query-term matches remain eligible.
+
 Use the same text-search configuration for document and query vectors. Select a language-specific or custom configuration that matches the corpus.
 
 ## Set the Candidate Limit
@@ -72,15 +78,19 @@ BEGIN;
 SET LOCAL lakebase_bm25.default_limit = 20;
 SET LOCAL lakebase_bm25.prefilter = on;
 
-SELECT
-  id,
-  title,
-  body_tsv <@> to_bm25query(
-    to_tsvector('english', $1),
-    'documents_body_bm25'::regclass
-  ) AS score
-FROM documents
-WHERE id % 1000 = 0
+SELECT id, title, score
+FROM (
+  SELECT
+    id,
+    title,
+    body_tsv <@> to_bm25query(
+      to_tsvector('english', $1),
+      'documents_body_bm25'::regclass
+    ) AS score
+  FROM documents
+  WHERE id % 1000 = 0
+) AS keyword_scored
+WHERE score < 0
 ORDER BY score
 LIMIT $2;
 COMMIT;

package/dist/global-skills/neon-postgres/references/hybrid-search.md

@@ -18,13 +18,13 @@ CREATE TABLE documents (
   id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
   title text NOT NULL,
   body text NOT NULL,
-  embedding vector(1536),
+  embedding vector(1024),
   body_tsv tsvector GENERATED ALWAYS AS
     (to_tsvector('english', body)) STORED
 );
 ```
 
-Replace `1536` with the embedding model's dimension. Use the same model and preprocessing for stored-document and query embeddings, and choose a PostgreSQL text-search configuration appropriate for the corpus.
+The 1024-dimensional column is an example. Set it to the output dimension of your selected embedding model. Generate document embeddings in batches and embed each query with the same model and dimensions; [Vector search](vector-search.md#prepare-embeddings) shows the AI Gateway calls. Follow any model-specific query instructions, while keeping the original query text for BM25. Choose a PostgreSQL text-search configuration appropriate for the corpus.
 
 Create and validate each retriever independently before combining them. Follow [Vector search](vector-search.md) and [Full-text search](full-text-search.md) for their indexes, query operators, and tuning.
 
@@ -34,7 +34,7 @@ Reciprocal Rank Fusion (RRF) is the approach in the Lakebase Search get-started
 
 For rank `r` and constant `k`, each retriever contributes `1 / (k + r)`. The documented starting point uses 40 candidates per retriever and `k = 60`; tune both for the corpus and workload.
 
-Bind the query embedding as `$1`, query text as `$2`, and final result count as `$3`:
+Embed the query text through the same gateway model used for the stored documents, then bind that vector as `$1`, the original query text as `$2`, and the final result count as `$3`:
 
 ```sql
 WITH vector_ranked AS (
@@ -49,15 +49,19 @@ WITH vector_ranked AS (
 keyword_ranked AS (
   SELECT id, RANK() OVER (ORDER BY score) AS rank
   FROM (
-    SELECT
-      id,
-      body_tsv <@> to_bm25query(
-        to_tsvector('english', $2),
-        'documents_body_bm25'::regclass
-      ) AS score
-    FROM documents
-    ORDER BY score
-    FETCH FIRST 40 ROWS WITH TIES
+    SELECT id, score
+    FROM (
+      SELECT
+        id,
+        body_tsv <@> to_bm25query(
+          to_tsvector('english', $2),
+          'documents_body_bm25'::regclass
+        ) AS score
+      FROM documents
+    ) AS keyword_scored
+    WHERE score < 0
+    ORDER BY score, id
+    LIMIT 40
   ) AS keyword_candidates
 )
 SELECT
@@ -73,13 +77,13 @@ ORDER BY rrf_score DESC, d.id
 LIMIT $3;
 ```
 
-`RANK()` gives tied retrieval scores the same rank. Sort by `rrf_score` descending and use the stable ID as a final tie-breaker.
+`score < 0` excludes BM25 non-matches. Many matching documents can share a BM25 score, so `WITH TIES` could admit a large group at the cutoff. `ORDER BY score, id LIMIT 40` keeps keyword candidates bounded and breaks boundary ties by ID. `RANK()` uses score alone so retained ties receive equal ranks.
 
-`FETCH FIRST ... ROWS WITH TIES` keeps every candidate tied at the cutoff, so `RANK()` receives the complete boundary tie group. The candidate set can therefore exceed 40 rows. `lakebase_bm25.default_limit` defaults to `1000`; increase it only when the BM25 candidate set needs to exceed that value.
+Vector retrieval preserves cutoff ties and can exceed 40 candidates. `lakebase_bm25.default_limit` defaults to `1000`; the SQL limit bounds keyword rows entering fusion, not total scoring work.
 
 ## Adapt the Hybrid Search
 
-- Retrieve more candidates from each source than the final result count; otherwise one retriever can dominate before fusion has enough overlap. Keep `lakebase_bm25.default_limit` above the BM25 candidate target and allow room for boundary ties.
+- Retrieve more candidates from each source than the final result count; otherwise one retriever can dominate before fusion has enough overlap. Keep `lakebase_bm25.default_limit` at least as large as the BM25 candidate target.
 - Keep each retriever's operator and index configuration correct independently before tuning RRF.
 - Tune candidate counts and the RRF constant with judged or behavioral relevance data, plus latency measurements.
 - Add weights only when product evidence shows one retriever should contribute more. Weight the reciprocal-rank contributions, not the raw vector distance and negative BM25 score.

package/dist/global-skills/neon-postgres/references/lakebase-search-drizzle.md

@@ -10,6 +10,7 @@ Contents:
 - [Extensions](#extensions): custom migration required to create extensions (Drizzle can't)
 - [Schema](#schema): columns, generated `tsvector`, and the ANN index
 - [BM25 Index](#bm25-index): created after the corpus is seeded
+- [Generate and Store Embeddings](#generate-and-store-embeddings): call the AI Gateway and insert vectors with Drizzle
 - [Query](#query): vector, BM25, and hybrid reads
 - [Tune Per Query](#tune-per-query): per-query GUCs
 
@@ -22,18 +23,22 @@ Rules:
 
 ## Config
 
-`drizzle-kit generate` and `migrate` read `drizzle.config.ts`. Point `dbCredentials.url` at the **direct (unpooled)** connection string:
+`drizzle-kit generate` and `migrate` read `drizzle.config.ts`. If the connection string is in `.env`, install `dotenv` (`npm install dotenv`) and load it here. Point `dbCredentials.url` at the **direct (unpooled)** connection string:
 
 ```typescript
 // drizzle.config.ts
+import "dotenv/config";
 import { defineConfig } from "drizzle-kit";
 
+const databaseUrl = process.env.DATABASE_URL_UNPOOLED;
+if (!databaseUrl) throw new Error("Missing DATABASE_URL_UNPOOLED");
+
 export default defineConfig({
   schema: "./src/schema.ts",
   out: "./drizzle",
   dialect: "postgresql",
   // Direct (unpooled) URL. Neon exposes it as DATABASE_URL_UNPOOLED.
-  dbCredentials: { url: process.env.DATABASE_URL_UNPOOLED },
+  dbCredentials: { url: databaseUrl },
 });
 ```
 
@@ -57,7 +62,14 @@ The columns, the generated `tsvector`, and the `lakebase_ann` index all go in `s
 
 ```typescript
 // src/schema.ts
-import { pgTable, bigint, text, vector, index, customType } from "drizzle-orm/pg-core";
+import {
+  pgTable,
+  bigint,
+  text,
+  vector,
+  index,
+  customType,
+} from "drizzle-orm/pg-core";
 import { sql } from "drizzle-orm";
 
 const tsvector = customType<{ data: string }>({
@@ -69,10 +81,12 @@ const tsvector = customType<{ data: string }>({
 export const documents = pgTable(
   "documents",
   {
-    id: bigint("id", { mode: "number" }).generatedByDefaultAsIdentity().primaryKey(),
+    id: bigint("id", { mode: "number" })
+      .generatedByDefaultAsIdentity()
+      .primaryKey(),
     title: text("title").notNull(),
     body: text("body").notNull(),
-    embedding: vector("embedding", { dimensions: 1536 }),
+    embedding: vector("embedding", { dimensions: 1024 }),
     bodyTsv: tsvector("body_tsv").generatedAlwaysAs(
       sql`to_tsvector('english', "body")`,
     ),
@@ -86,7 +100,7 @@ export const documents = pgTable(
 );
 ```
 
-Set the dimension to match your embedding model. Postgres maintains `body_tsv`, so never write it from the app. Generate and apply the migration after the extensions migration above:
+The 1024-dimensional column is an example; set it to the output dimension of your selected embedding model. Use the same model and dimensions for stored documents and queries. Postgres maintains `body_tsv`, so never write it from the app. Generate and apply the migration after the extensions migration above:
 
 ```bash
 npx drizzle-kit generate --name=lakebase_search
@@ -106,6 +120,66 @@ npx drizzle-kit generate --custom --name=bm25_index
 CREATE INDEX documents_body_bm25 ON documents USING lakebase_bm25 (body_tsv);
 ```
 
+## Generate and Store Embeddings
+
+Use the [Vercel AI SDK](https://ai-sdk.dev) (`ai`, 6+) with Neon's `@neon/ai-sdk-provider` 1.0.0+. Follow the [gateway setup](vector-search.md#prepare-embeddings), then install the packages with `npm install @neon/ai-sdk-provider ai dotenv`:
+
+```typescript
+import "dotenv/config";
+import { neon } from "@neon/ai-sdk-provider";
+import { embed, embedMany } from "ai";
+
+const embeddingModel = neon.embeddingModel("qwen3-embedding-0-6b");
+const providerOptions = { neon: { dimensions: 1024 } };
+// Qwen3 query prompt adapted for Neon documentation search; documents stay unprefixed.
+const queryPrompt =
+  "Instruct: Given a question about Neon, retrieve documentation passages that answer the question\nQuery: ";
+```
+
+Generate a document vector, then insert it with Drizzle:
+
+```typescript
+const { embedding } = await embed({
+  model: embeddingModel,
+  value: body,
+  providerOptions,
+});
+await db.insert(documents).values({
+  title,
+  body,
+  embedding,
+});
+```
+
+For bulk imports, skip blank rows and embed/insert one batch at a time:
+
+```typescript
+const batchSize = 64;
+const nonBlankRows = rows.filter((row) => row && row.body.trim().length > 0);
+
+for (let offset = 0; offset < nonBlankRows.length; offset += batchSize) {
+  const batch = nonBlankRows.slice(offset, offset + batchSize);
+  const { embeddings: vectors } = await embedMany({
+    model: embeddingModel,
+    values: batch.map((row) => row.body),
+    providerOptions,
+    maxParallelCalls: 1,
+  });
+  await db.insert(documents).values(
+    batch.map((row, index) => {
+      const embedding = vectors[index];
+      if (!embedding)
+        throw new Error(`Missing embedding for batch row ${index}`);
+      return { ...row, embedding };
+    }),
+  );
+}
+```
+
+`embedMany` splits embedding requests using the provider's per-request input limit. This loop also bounds database inserts and memory; tune `batchSize` for your workload. Chunk long documents before embedding. Earlier batches stay committed if a later batch fails.
+
+Apply `queryPrompt` only to queries, keeping the original text for BM25. Use the same model and dimensions for documents and queries; re-embed documents when switching models.
+
 ## Query
 
 Use the query builder with Drizzle's `cosineDistance` helper for vector search. It emits the `<=>` operator, so keep the index on `vector_cosine_ops`:
@@ -114,7 +188,11 @@ Use the query builder with Drizzle's `cosineDistance` helper for vector search.
 import { cosineDistance } from "drizzle-orm";
 import { documents } from "./schema";
 
-// queryEmbedding: number[] from the same model used for stored documents
+const { embedding: queryEmbedding } = await embed({
+  model: embeddingModel,
+  value: `${queryPrompt}${queryText}`,
+  providerOptions,
+});
 const distance = cosineDistance(documents.embedding, queryEmbedding);
 
 const rows = await db
@@ -130,17 +208,23 @@ BM25 has no Drizzle helper: `<@>` and `to_bm25query` require raw SQL. Reference
 import { sql } from "drizzle-orm";
 
 const rows = await db.execute(sql`
-  SELECT id, title,
-    body_tsv <@> to_bm25query(
-      to_tsvector('english', ${queryText}),
-      'documents_body_bm25'::regclass
-    ) AS score
-  FROM documents
+  SELECT id, title, score
+  FROM (
+    SELECT id, title,
+      body_tsv <@> to_bm25query(
+        to_tsvector('english', ${queryText}),
+        'documents_body_bm25'::regclass
+      ) AS score
+    FROM documents
+  ) AS keyword_scored
+  WHERE score < 0
   ORDER BY score
   LIMIT ${k}
 `);
 ```
 
+Filter `score < 0` before the candidate cutoff: scalar BM25 scoring returns zero for non-matches, which must not become keyword hits. Partial query-term matches remain eligible.
+
 Run the [hybrid search](hybrid-search.md) RRF query the same way: raw SQL through `db.execute`.
 
 ## Tune Per Query
@@ -168,5 +252,6 @@ const rows = await db.transaction(async (tx) => {
 
 Sources:
 
+- [AI Gateway embeddings](https://neon.com/docs/ai-gateway/embeddings)
 - [Get started with Lakebase Search](https://neon.com/docs/ai/lakebase-search-get-started)
-- [Schema migration with Lakebase Postgres and Drizzle ORM](https://neon.com/docs/guides/drizzle-migrations)
+- [Schema migration with Lakebase Postgres and Drizzle ORM](https://neon.com/docs/guides/drizzle-migrations)