graphile-llm 0.2.0

package/esm/plugins/text-search-plugin.js

@@ -0,0 +1,163 @@
+/**
+ * LlmTextSearchPlugin
+ *
+ * Adds a `text: String` field to `VectorNearbyInput` when the LLM plugin
+ * is enabled. This allows clients to pass natural language text instead of
+ * raw float vectors for similarity search — the plugin converts text to
+ * vectors server-side using the configured embedder.
+ *
+ * This mirrors the graphile-postgis pattern where `WithinDistanceInput`
+ * accepts a compound input (point + distance) and the plugin handles
+ * the conversion to SQL internally.
+ *
+ * The `text` field is mutually exclusive with `vector`: clients provide
+ * one or the other. When `text` is provided, the plugin embeds it and
+ * injects the resulting vector into the normal pgvector pipeline.
+ *
+ * Runtime embedding for query filters uses the v4-style resolver wrapping
+ * approach (same as graphile-upload-plugin). When a connection query's
+ * `where` argument includes a VectorNearbyInput with `text`, the resolver
+ * wrapper embeds the text and replaces it with the resulting vector before
+ * the plan executes.
+ *
+ * If the embedder is not configured, the `text` field is still registered
+ * (so the schema is stable) but will return a clear error at execution time.
+ */
+/**
+ * Check if a codec has any pgvector `vector` columns.
+ */
+function hasVectorColumns(pgCodec) {
+    if (!pgCodec?.attributes)
+        return false;
+    for (const attribute of Object.values(pgCodec.attributes)) {
+        if (attribute.codec?.name === 'vector')
+            return true;
+    }
+    return false;
+}
+/**
+ * Recursively walk a `where` argument object and embed any VectorNearbyInput
+ * values that have `text` instead of `vector`.
+ */
+async function embedTextInWhere(obj, embedder) {
+    if (!obj || typeof obj !== 'object')
+        return;
+    const pending = [];
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (!value || typeof value !== 'object')
+            continue;
+        // Detect VectorNearbyInput shape: has `text` and no `vector`
+        if ('text' in value && typeof value.text === 'string' && !value.vector) {
+            pending.push((async () => {
+                const startTime = Date.now();
+                const vector = await embedder(value.text);
+                const latencyMs = Date.now() - startTime;
+                console.log(`[graphile-llm] Search embed: field=${key}, dims=${vector.length}, latency=${latencyMs}ms`);
+                // Replace text with vector
+                value.vector = vector;
+                delete value.text;
+            })());
+            continue;
+        }
+        // Recurse into nested filter objects (AND, OR, etc.)
+        if (!Array.isArray(value)) {
+            pending.push(embedTextInWhere(value, embedder));
+        }
+        else {
+            // Handle arrays (e.g. AND: [...], OR: [...])
+            for (const item of value) {
+                pending.push(embedTextInWhere(item, embedder));
+            }
+        }
+    }
+    if (pending.length > 0) {
+        await Promise.all(pending);
+    }
+}
+/**
+ * Creates the LlmTextSearchPlugin.
+ *
+ * Hooks into VectorNearbyInput to add a `text` field alongside the
+ * existing `vector` field. When a user provides `text`, the plugin's
+ * resolver wrapper embeds it before passing to pgvector.
+ */
+export function createLlmTextSearchPlugin() {
+    return {
+        name: 'LlmTextSearchPlugin',
+        version: '0.1.0',
+        description: 'Adds text-to-vector embedding support on VectorNearbyInput filter fields',
+        after: [
+            'LlmModulePlugin',
+            'UnifiedSearchPlugin',
+            'VectorCodecPlugin',
+        ],
+        schema: {
+            hooks: {
+                /**
+                 * Add the `text: String` field to VectorNearbyInput.
+                 *
+                 * We intercept VectorNearbyInput specifically and add a `text` field.
+                 * The field is optional — clients provide either `text` or `vector`.
+                 */
+                GraphQLInputObjectType_fields(fields, build, context) {
+                    const { scope: { inputObjectTypeName }, } = context;
+                    if (inputObjectTypeName !== 'VectorNearbyInput') {
+                        return fields;
+                    }
+                    const { graphql: { GraphQLString }, } = build;
+                    return build.extend(fields, {
+                        text: {
+                            type: GraphQLString,
+                            description: 'Natural language text to embed server-side for similarity search. ' +
+                                'Mutually exclusive with `vector` — provide one or the other. ' +
+                                'Requires the LLM plugin to be configured with an embedding provider.',
+                        },
+                    }, 'LlmTextSearchPlugin adding text field to VectorNearbyInput');
+                },
+                /**
+                 * Wrap connection query resolvers to intercept `where` arguments that
+                 * contain VectorNearbyInput with `text`, embed the text, and replace
+                 * it with the resulting vector before the plan executes.
+                 *
+                 * Uses the same v4-style resolver wrapping pattern as graphile-upload-plugin
+                 * and graphile-bucket-provisioner-plugin.
+                 */
+                GraphQLObjectType_fields_field(field, build, context) {
+                    const { scope: { isRootQuery, pgCodec }, } = context;
+                    // Only wrap root query fields on tables with vector columns
+                    if (!isRootQuery || !pgCodec || !hasVectorColumns(pgCodec)) {
+                        return field;
+                    }
+                    const embedder = build.llmEmbedder;
+                    if (!embedder)
+                        return field;
+                    const defaultResolver = (obj) => obj[context.scope.fieldName];
+                    const { resolve: oldResolve = defaultResolver, ...rest } = field;
+                    return {
+                        ...rest,
+                        async resolve(source, args, graphqlContext, info) {
+                            // If the query has a `where` argument, check for text fields
+                            if (args?.where) {
+                                await embedTextInWhere(args.where, embedder);
+                            }
+                            // Also handle `filter` for relay-style connections
+                            if (args?.filter) {
+                                await embedTextInWhere(args.filter, embedder);
+                            }
+                            return oldResolve(source, args, graphqlContext, info);
+                        },
+                    };
+                },
+                finalize(schema, build) {
+                    const embedder = build.llmEmbedder;
+                    if (!embedder) {
+                        console.log('[graphile-llm] No embedder available — text field on VectorNearbyInput ' +
+                            'will return errors if used. Configure an embedding provider to enable.');
+                    }
+                    return schema;
+                },
+            },
+        },
+    };
+}

package/esm/preset.d.ts

@@ -0,0 +1,55 @@
+/**
+ * GraphileLlmPreset
+ *
+ * A preset that bundles all LLM plugins for PostGraphile v5.
+ * This is the recommended entry point — add it to your preset's `extends` array.
+ *
+ * When enabled, this preset:
+ * - Resolves an embedder from configuration (llm_module, env vars, or preset options)
+ * - Adds a `text: String` field to `VectorNearbyInput` for text-based vector search
+ * - Adds `{column}Text: String` companion fields on mutation inputs for vector columns
+ * - Logs token usage to console (metering integration deferred to billing system)
+ *
+ * This preset is standalone — it is NOT included in ConstructivePreset by default.
+ * Projects that want LLM features opt in by adding it to their preset.
+ *
+ * @example
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConstructivePreset,
+ *     GraphileLlmPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example With explicit embedder configuration:
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConstructivePreset,
+ *     GraphileLlmPreset({
+ *       defaultEmbedder: {
+ *         provider: 'ollama',
+ *         model: 'nomic-embed-text',
+ *         baseUrl: 'http://localhost:11434',
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+import type { GraphileConfig } from 'graphile-config';
+import type { GraphileLlmOptions } from './types';
+/**
+ * Creates a preset that includes all LLM plugins.
+ *
+ * @param options - Configuration options for the LLM plugin
+ * @returns A GraphileConfig.Preset to add to your extends array
+ */
+export declare function GraphileLlmPreset(options?: GraphileLlmOptions): GraphileConfig.Preset;
+export default GraphileLlmPreset;

package/esm/preset.js

@@ -0,0 +1,74 @@
+/**
+ * GraphileLlmPreset
+ *
+ * A preset that bundles all LLM plugins for PostGraphile v5.
+ * This is the recommended entry point — add it to your preset's `extends` array.
+ *
+ * When enabled, this preset:
+ * - Resolves an embedder from configuration (llm_module, env vars, or preset options)
+ * - Adds a `text: String` field to `VectorNearbyInput` for text-based vector search
+ * - Adds `{column}Text: String` companion fields on mutation inputs for vector columns
+ * - Logs token usage to console (metering integration deferred to billing system)
+ *
+ * This preset is standalone — it is NOT included in ConstructivePreset by default.
+ * Projects that want LLM features opt in by adding it to their preset.
+ *
+ * @example
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConstructivePreset,
+ *     GraphileLlmPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example With explicit embedder configuration:
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConstructivePreset,
+ *     GraphileLlmPreset({
+ *       defaultEmbedder: {
+ *         provider: 'ollama',
+ *         model: 'nomic-embed-text',
+ *         baseUrl: 'http://localhost:11434',
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+import { createLlmModulePlugin } from './plugins/llm-module-plugin';
+import { createLlmTextSearchPlugin } from './plugins/text-search-plugin';
+import { createLlmTextMutationPlugin } from './plugins/text-mutation-plugin';
+import { createLlmRagPlugin } from './plugins/rag-plugin';
+/**
+ * Creates a preset that includes all LLM plugins.
+ *
+ * @param options - Configuration options for the LLM plugin
+ * @returns A GraphileConfig.Preset to add to your extends array
+ */
+export function GraphileLlmPreset(options = {}) {
+    const { enableTextSearch = true, enableTextMutations = true, enableRag = false, ragDefaults, } = options;
+    const plugins = [
+        createLlmModulePlugin(options),
+    ];
+    if (enableTextSearch) {
+        plugins.push(createLlmTextSearchPlugin());
+    }
+    if (enableTextMutations) {
+        plugins.push(createLlmTextMutationPlugin());
+    }
+    if (enableRag) {
+        plugins.push(createLlmRagPlugin(ragDefaults));
+    }
+    return {
+        plugins,
+    };
+}
+export default GraphileLlmPreset;

package/esm/types.d.ts

@@ -0,0 +1,173 @@
+/**
+ * graphile-llm Types
+ *
+ * Shared type definitions for the LLM plugin.
+ */
+/**
+ * A function that converts text into a vector embedding.
+ */
+export type EmbedderFunction = (text: string) => Promise<number[]>;
+/**
+ * Configuration for an embedding provider.
+ */
+export interface EmbedderConfig {
+    /** Provider name: 'ollama', 'openai', or 'custom' */
+    provider: string;
+    /** Model identifier (e.g. 'nomic-embed-text', 'text-embedding-3-small') */
+    model?: string;
+    /** Base URL for the provider (e.g. 'http://localhost:11434' for Ollama) */
+    baseUrl?: string;
+    /** API key for providers that require authentication (e.g. OpenAI) */
+    apiKey?: string;
+}
+/**
+ * A single message in a chat conversation.
+ */
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Options for a chat completion request.
+ */
+export interface ChatOptions {
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature for sampling (0 = deterministic, 1 = creative) */
+    temperature?: number;
+}
+/**
+ * A function that sends messages to a chat completion provider and returns the response.
+ */
+export type ChatFunction = (messages: ChatMessage[], options?: ChatOptions) => Promise<string>;
+/**
+ * Configuration for a chat completion provider.
+ */
+export interface ChatConfig {
+    /** Provider name: 'ollama', 'openai', or 'custom' */
+    provider: string;
+    /** Model identifier (e.g. 'llama3', 'gpt-4o') */
+    model?: string;
+    /** Base URL for the provider */
+    baseUrl?: string;
+    /** API key for providers that require authentication */
+    apiKey?: string;
+}
+/**
+ * The shape of the `llm_module` data stored in `services_public.api_modules`.
+ *
+ * This is the per-database configuration that controls which LLM provider
+ * and models are available for that API.
+ */
+export interface LlmModuleData {
+    /** Embedding provider: 'ollama', 'openai', or 'custom' */
+    embedding_provider: string;
+    /** Embedding model identifier */
+    embedding_model?: string;
+    /** Base URL for the embedding provider */
+    embedding_base_url?: string;
+    /** Number of dimensions the embedding model produces */
+    embedding_dimensions?: number;
+    /** Chat/completion provider (for RAG/conversation features) */
+    chat_provider?: string;
+    /** Chat model identifier */
+    chat_model?: string;
+    /** Base URL for the chat provider */
+    chat_base_url?: string;
+    /** API key reference (e.g. 'vault://openai-key' or env var name) */
+    api_key_ref?: string;
+    /** Rate limit: requests per minute */
+    rate_limit_rpm?: number;
+    /** Maximum tokens per request */
+    max_tokens_per_request?: number;
+    /** Default number of context items for RAG queries */
+    rag_context_limit?: number;
+}
+/**
+ * Default configuration for RAG (Retrieval-Augmented Generation) queries.
+ */
+export interface RagDefaults {
+    /**
+     * Default number of context items to feed into the RAG prompt.
+     * Per-query `contextLimit` overrides this.
+     * @default 5
+     */
+    contextLimit?: number;
+    /**
+     * Default maximum tokens for the chat completion response.
+     * @default 4000
+     */
+    maxTokens?: number;
+    /**
+     * Default minimum similarity threshold (0..1).
+     * Only chunks with similarity >= this threshold are included.
+     * Converted to max distance internally (1 - minSimilarity for cosine).
+     * @default 0 (no threshold)
+     */
+    minSimilarity?: number;
+    /**
+     * Default system prompt prepended to RAG context.
+     * Can be overridden per-query.
+     */
+    systemPrompt?: string;
+}
+/**
+ * Info about a chunk-aware table discovered during schema build.
+ * Parsed from the @hasChunks smart tag on the parent table's codec.
+ */
+export interface ChunkTableInfo {
+    /** Parent table codec name */
+    parentCodecName: string;
+    /** Schema of the chunks table (or null for public/default) */
+    chunksSchema: string | null;
+    /** Name of the chunks table */
+    chunksTableName: string;
+    /** FK column on chunks table pointing to parent */
+    parentFkField: string;
+    /** PK column on parent table */
+    parentPkField: string;
+    /** Embedding vector column on chunks table */
+    embeddingField: string;
+    /** Text content column on chunks table (the actual chunk text) */
+    contentField: string;
+}
+/**
+ * Options for the GraphileLlmPreset.
+ */
+export interface GraphileLlmOptions {
+    /**
+     * Default embedding provider when no llm_module is configured.
+     * Useful for development/testing without requiring api_modules setup.
+     * @default undefined (requires llm_module to be configured)
+     */
+    defaultEmbedder?: EmbedderConfig;
+    /**
+     * Default chat completion provider when no llm_module is configured.
+     * Required for RAG queries.
+     * @default undefined
+     */
+    defaultChatCompleter?: ChatConfig;
+    /**
+     * Whether to add `text` field to VectorNearbyInput for text-based vector search.
+     * @default true
+     */
+    enableTextSearch?: boolean;
+    /**
+     * Whether to add `*Text` companion fields on mutation inputs for vector columns.
+     * @default true
+     */
+    enableTextMutations?: boolean;
+    /**
+     * Whether to enable RAG (Retrieval-Augmented Generation) query support.
+     * When enabled, detects tables with @hasChunks smart tag and adds:
+     * - `ragQuery` root query field for context-aware LLM answers
+     * - `embedText` root query field for text-to-vector conversion
+     * @default false
+     */
+    enableRag?: boolean;
+    /**
+     * Default configuration for RAG queries.
+     * Individual queries can override these values.
+     */
+    ragDefaults?: RagDefaults;
+}

package/esm/types.js

@@ -0,0 +1,6 @@
+/**
+ * graphile-llm Types
+ *
+ * Shared type definitions for the LLM plugin.
+ */
+export {};

package/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * graphile-llm — LLM Integration Plugin for PostGraphile v5
+ *
+ * Server-side text-to-vector embedding, text companion fields for pgvector
+ * columns, and RAG (Retrieval-Augmented Generation) query support.
+ *
+ * Moves the embedding logic from the client (CLI --auto-embed) into the
+ * Graphile server layer so clients work with text/prompts instead of raw
+ * float vectors.
+ *
+ * @example
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     GraphileLlmPreset({
+ *       defaultEmbedder: {
+ *         provider: 'ollama',
+ *         model: 'nomic-embed-text',
+ *       },
+ *       defaultChatCompleter: {
+ *         provider: 'ollama',
+ *         model: 'llama3',
+ *       },
+ *       enableRag: true,
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export { GraphileLlmPreset } from './preset';
+export { createLlmModulePlugin } from './plugins/llm-module-plugin';
+export { createLlmTextSearchPlugin } from './plugins/text-search-plugin';
+export { createLlmTextMutationPlugin } from './plugins/text-mutation-plugin';
+export { createLlmRagPlugin } from './plugins/rag-plugin';
+export { buildEmbedder, buildEmbedderFromModule, buildEmbedderFromEnv, } from './embedder';
+export { buildChatCompleter, buildChatCompleterFromModule, buildChatCompleterFromEnv, } from './chat';
+export type { EmbedderFunction, EmbedderConfig, ChatFunction, ChatConfig, ChatMessage, ChatOptions, LlmModuleData, GraphileLlmOptions, RagDefaults, ChunkTableInfo, } from './types';

package/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * graphile-llm — LLM Integration Plugin for PostGraphile v5
+ *
+ * Server-side text-to-vector embedding, text companion fields for pgvector
+ * columns, and RAG (Retrieval-Augmented Generation) query support.
+ *
+ * Moves the embedding logic from the client (CLI --auto-embed) into the
+ * Graphile server layer so clients work with text/prompts instead of raw
+ * float vectors.
+ *
+ * @example
+ * ```typescript
+ * import { GraphileLlmPreset } from 'graphile-llm';
+ *
+ * const preset = {
+ *   extends: [
+ *     GraphileLlmPreset({
+ *       defaultEmbedder: {
+ *         provider: 'ollama',
+ *         model: 'nomic-embed-text',
+ *       },
+ *       defaultChatCompleter: {
+ *         provider: 'ollama',
+ *         model: 'llama3',
+ *       },
+ *       enableRag: true,
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChatCompleterFromEnv = exports.buildChatCompleterFromModule = exports.buildChatCompleter = exports.buildEmbedderFromEnv = exports.buildEmbedderFromModule = exports.buildEmbedder = exports.createLlmRagPlugin = exports.createLlmTextMutationPlugin = exports.createLlmTextSearchPlugin = exports.createLlmModulePlugin = exports.GraphileLlmPreset = void 0;
+// Preset (recommended entry point)
+var preset_1 = require("./preset");
+Object.defineProperty(exports, "GraphileLlmPreset", { enumerable: true, get: function () { return preset_1.GraphileLlmPreset; } });
+// Individual plugins
+var llm_module_plugin_1 = require("./plugins/llm-module-plugin");
+Object.defineProperty(exports, "createLlmModulePlugin", { enumerable: true, get: function () { return llm_module_plugin_1.createLlmModulePlugin; } });
+var text_search_plugin_1 = require("./plugins/text-search-plugin");
+Object.defineProperty(exports, "createLlmTextSearchPlugin", { enumerable: true, get: function () { return text_search_plugin_1.createLlmTextSearchPlugin; } });
+var text_mutation_plugin_1 = require("./plugins/text-mutation-plugin");
+Object.defineProperty(exports, "createLlmTextMutationPlugin", { enumerable: true, get: function () { return text_mutation_plugin_1.createLlmTextMutationPlugin; } });
+var rag_plugin_1 = require("./plugins/rag-plugin");
+Object.defineProperty(exports, "createLlmRagPlugin", { enumerable: true, get: function () { return rag_plugin_1.createLlmRagPlugin; } });
+// Embedder utilities
+var embedder_1 = require("./embedder");
+Object.defineProperty(exports, "buildEmbedder", { enumerable: true, get: function () { return embedder_1.buildEmbedder; } });
+Object.defineProperty(exports, "buildEmbedderFromModule", { enumerable: true, get: function () { return embedder_1.buildEmbedderFromModule; } });
+Object.defineProperty(exports, "buildEmbedderFromEnv", { enumerable: true, get: function () { return embedder_1.buildEmbedderFromEnv; } });
+// Chat completion utilities
+var chat_1 = require("./chat");
+Object.defineProperty(exports, "buildChatCompleter", { enumerable: true, get: function () { return chat_1.buildChatCompleter; } });
+Object.defineProperty(exports, "buildChatCompleterFromModule", { enumerable: true, get: function () { return chat_1.buildChatCompleterFromModule; } });
+Object.defineProperty(exports, "buildChatCompleterFromEnv", { enumerable: true, get: function () { return chat_1.buildChatCompleterFromEnv; } });

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "graphile-llm",
+  "version": "0.2.0",
+  "description": "LLM integration plugin for PostGraphile v5 — server-side text-to-vector embedding and text companion fields for pgvector columns",
+  "author": "Constructive <developers@constructive.io>",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest --forceExit",
+    "test:watch": "jest --watch"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "dependencies": {
+    "@agentic-kit/ollama": "^1.0.3"
+  },
+  "peerDependencies": {
+    "@dataplan/pg": "1.0.0",
+    "grafast": "1.0.0",
+    "graphile-build": "5.0.0",
+    "graphile-build-pg": "5.0.0",
+    "graphile-config": "1.0.0",
+    "graphile-search": "workspace:^",
+    "graphile-utils": "5.0.0",
+    "graphql": "16.13.0",
+    "pg-sql2": "5.0.0",
+    "postgraphile": "5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "graphile-search": {
+      "optional": true
+    },
+    "graphile-utils": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11",
+    "graphile-connection-filter": "^1.5.1",
+    "graphile-search": "^1.7.1",
+    "graphile-test": "^4.9.0",
+    "makage": "^0.3.0",
+    "pgsql-test": "^4.9.0"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "constructive",
+    "plugin",
+    "llm",
+    "embedding",
+    "pgvector",
+    "rag",
+    "agentic-kit",
+    "ollama",
+    "openai"
+  ],
+  "gitHead": "e52a76e08338b00aa866f7cea3abb7414a3ac34c"
+}

package/plugins/llm-module-plugin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LlmModulePlugin
+ *
+ * Detects and loads the `llm_module` configuration from `services_public.api_modules`.
+ * Makes the resolved embedder available to other plugins via the build context.
+ *
+ * This plugin is the foundation that enables per-database LLM configuration.
+ * When an API has an `llm_module` configured, the embedder is resolved and
+ * stored on the build object for other plugins (text search, text mutations)
+ * to consume.
+ *
+ * Resolution order for the embedder:
+ *   1. `llm_module` from api_modules (per-database, loaded at schema build time)
+ *   2. `defaultEmbedder` from preset options (dev/testing fallback)
+ *   3. Environment variables (EMBEDDER_PROVIDER, EMBEDDER_MODEL, EMBEDDER_BASE_URL)
+ *   4. null — LLM features are disabled
+ */
+import type { GraphileConfig } from 'graphile-config';
+import type { EmbedderFunction, ChatFunction, GraphileLlmOptions } from '../types';
+declare global {
+    namespace GraphileBuild {
+        interface Build {
+            /** The resolved embedder function, or null if LLM is not configured */
+            llmEmbedder: EmbedderFunction | null;
+            /** The resolved chat completion function, or null if not configured */
+            llmChatCompleter: ChatFunction | null;
+        }
+    }
+    namespace GraphileConfig {
+        interface Plugins {
+            LlmModulePlugin: true;
+        }
+    }
+}
+/**
+ * Creates the LlmModulePlugin with the given options.
+ */
+export declare function createLlmModulePlugin(options?: GraphileLlmOptions): GraphileConfig.Plugin;