graphile-llm 0.2.0

package/esm/plugins/rag-plugin.js

@@ -0,0 +1,341 @@
+/**
+ * LlmRagPlugin
+ *
+ * Adds RAG (Retrieval-Augmented Generation) query support to PostGraphile v5.
+ *
+ * When enabled, this plugin:
+ * 1. Discovers tables with @hasChunks smart tag during schema build
+ * 2. Adds a `ragQuery` root query field that orchestrates:
+ *    embed prompt → pgvector search chunks → assemble context → call chat LLM → return answer
+ * 3. Adds an `embedText` root query field for standalone text-to-vector conversion
+ *
+ * Uses the extendSchema + grafast lambda pattern (same as bucket-provisioner
+ * and presigned-url plugins) for async operations at execution time.
+ *
+ * RAG is a consumer of graphile-search's pgvector adapter — it uses the existing
+ * chunk-aware tables but orchestrates the full LLM synthesis pipeline.
+ *
+ * Resolution order for embedder and chat completer:
+ *   1. build.llmEmbedder / build.llmChatCompleter (from LlmModulePlugin)
+ *   2. Falls back to error if not configured
+ */
+import { context as grafastContext, lambda, object } from 'grafast';
+import { extendSchema, gql } from 'graphile-utils';
+// ─── Constants ──────────────────────────────────────────────────────────────
+const DEFAULT_CONTEXT_LIMIT = 5;
+const DEFAULT_MAX_TOKENS = 4000;
+const DEFAULT_MIN_SIMILARITY = 0;
+const DEFAULT_SYSTEM_PROMPT = 'You are a helpful assistant. Answer the user\'s question based ONLY on the ' +
+    'following context. If the context does not contain enough information to ' +
+    'answer, say so. Do not make up information.\n\n' +
+    '--- CONTEXT ---\n';
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/**
+ * Parse @hasChunks smart tag from a codec's extensions into ChunkTableInfo.
+ * Mirrors the parsing logic in graphile-search's pgvector adapter.
+ */
+function parseHasChunksTag(raw, codec) {
+    let parsed;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (typeof raw === 'object' && raw !== null) {
+        parsed = raw;
+    }
+    else {
+        return null;
+    }
+    if (!parsed.chunksTable)
+        return null;
+    const chunksSchema = parsed.chunksSchema
+        || codec?.extensions?.pg?.schemaName
+        || null;
+    return {
+        parentCodecName: codec.name || 'unknown',
+        chunksSchema,
+        chunksTableName: parsed.chunksTable,
+        parentFkField: parsed.parentFk || 'parent_id',
+        parentPkField: parsed.parentPk || 'id',
+        embeddingField: parsed.embeddingField || 'embedding',
+        contentField: parsed.contentField || 'content',
+    };
+}
+/**
+ * Discover all chunk-aware tables from the pgRegistry.
+ */
+function discoverChunkTables(build) {
+    const chunkTables = [];
+    const pgRegistry = build.pgRegistry;
+    if (!pgRegistry)
+        return chunkTables;
+    // Scan all codecs for @hasChunks smart tag
+    for (const source of Object.values(pgRegistry.pgResources || {})) {
+        const codec = source?.codec;
+        if (!codec?.attributes)
+            continue;
+        const tags = codec.extensions?.tags;
+        if (!tags?.hasChunks)
+            continue;
+        const info = parseHasChunksTag(tags.hasChunks, codec);
+        if (info) {
+            chunkTables.push(info);
+        }
+    }
+    return chunkTables;
+}
+/**
+ * Build a SQL query string to search a chunks table for similar embeddings.
+ */
+function buildChunkSearchSql(table, vectorString, limit, maxDistance) {
+    const schema = table.chunksSchema;
+    const qualifiedTable = schema
+        ? `"${schema}"."${table.chunksTableName}"`
+        : `"${table.chunksTableName}"`;
+    const embeddingCol = `"${table.embeddingField}"`;
+    const contentCol = `"${table.contentField}"`;
+    const parentFkCol = `"${table.parentFkField}"`;
+    let text = `
+    SELECT
+      ${contentCol} AS content,
+      ${parentFkCol}::text AS parent_id,
+      (${embeddingCol} <=> $1::vector) AS distance
+    FROM ${qualifiedTable}
+  `;
+    const values = [vectorString];
+    if (maxDistance !== null) {
+        text += ` WHERE (${embeddingCol} <=> $1::vector) <= $2`;
+        values.push(maxDistance);
+    }
+    text += ` ORDER BY ${embeddingCol} <=> $1::vector LIMIT $${values.length + 1}`;
+    values.push(limit);
+    return { text, values };
+}
+/**
+ * Assemble retrieved chunks into a context string for the LLM prompt.
+ */
+function assembleContext(chunks) {
+    return chunks
+        .map((chunk, i) => `[Source ${i + 1}] (similarity: ${(1 - chunk.distance).toFixed(3)})\n${chunk.content}`)
+        .join('\n\n---\n\n');
+}
+// ─── Plugin Factory ─────────────────────────────────────────────────────────
+/**
+ * Creates the LlmRagPlugin.
+ *
+ * @param ragDefaults - Default configuration for RAG queries
+ */
+export function createLlmRagPlugin(ragDefaults = {}) {
+    // Chunk tables discovered during schema build, used by the plan at execution time
+    let chunkTables = [];
+    let embedder = null;
+    let chatCompleter = null;
+    const schemaExtension = extendSchema((build) => {
+        // Discover chunk-aware tables from pgRegistry
+        chunkTables = discoverChunkTables(build);
+        embedder = build.llmEmbedder || null;
+        chatCompleter = build.llmChatCompleter || null;
+        if (chunkTables.length > 0) {
+            console.log(`[graphile-llm] RAG plugin discovered ${chunkTables.length} chunk-aware table(s): ` +
+                chunkTables.map((t) => t.parentCodecName).join(', '));
+        }
+        else {
+            console.log('[graphile-llm] RAG plugin found no @hasChunks tables. ' +
+                'ragQuery will still work if chunks tables are queried directly.');
+        }
+        return {
+            typeDefs: gql `
+        """A source chunk retrieved during RAG context assembly."""
+        type RagSource {
+          """The text content of the retrieved chunk."""
+          content: String!
+          """Cosine similarity score (0..1, higher = more similar)."""
+          similarity: Float!
+          """The parent table this chunk belongs to."""
+          tableName: String
+          """The parent row ID this chunk belongs to."""
+          parentId: String
+        }
+
+        """Response from a RAG (Retrieval-Augmented Generation) query."""
+        type RagResponse {
+          """The LLM-generated answer based on retrieved context."""
+          answer: String!
+          """The source chunks used as context for the answer."""
+          sources: [RagSource!]!
+          """Approximate token count for the request (logging only, not metered)."""
+          tokensUsed: Int
+        }
+
+        """Response from an embedText query."""
+        type EmbedTextResponse {
+          """The resulting vector embedding."""
+          vector: [Float!]!
+          """Number of dimensions in the vector."""
+          dimensions: Int!
+        }
+
+        extend type Query {
+          """
+          RAG (Retrieval-Augmented Generation) query.
+          Embeds the prompt, searches chunk-aware tables for similar content,
+          assembles context, and calls the chat LLM to generate an answer.
+          Requires both an embedding provider and a chat provider to be configured.
+          """
+          ragQuery(
+            """The natural language question or prompt."""
+            prompt: String!
+            """Maximum number of context chunks to include (default: 5)."""
+            contextLimit: Int
+            """Minimum similarity threshold (0..1). Chunks below this are excluded."""
+            minSimilarity: Float
+            """Custom system prompt. Overrides the default RAG system prompt."""
+            systemPrompt: String
+          ): RagResponse
+
+          """
+          Convert text to a vector embedding using the configured embedding provider.
+          Useful for client-side vector operations when you need the raw vector.
+          """
+          embedText(
+            """The text to embed."""
+            text: String!
+          ): EmbedTextResponse
+        }
+      `,
+            plans: {
+                Query: {
+                    ragQuery(_$root, fieldArgs) {
+                        const $prompt = fieldArgs.getRaw('prompt');
+                        const $contextLimit = fieldArgs.getRaw('contextLimit');
+                        const $minSimilarity = fieldArgs.getRaw('minSimilarity');
+                        const $systemPrompt = fieldArgs.getRaw('systemPrompt');
+                        const $withPgClient = grafastContext().get('withPgClient');
+                        const $pgSettings = grafastContext().get('pgSettings');
+                        const $combined = object({
+                            prompt: $prompt,
+                            contextLimit: $contextLimit,
+                            minSimilarity: $minSimilarity,
+                            systemPrompt: $systemPrompt,
+                            withPgClient: $withPgClient,
+                            pgSettings: $pgSettings,
+                        });
+                        return lambda($combined, async (input) => {
+                            const { prompt, contextLimit: queryContextLimit, minSimilarity: queryMinSimilarity, systemPrompt: querySystemPrompt, withPgClient, pgSettings, } = input;
+                            if (!prompt || typeof prompt !== 'string') {
+                                throw new Error('RAG_INVALID_PROMPT: prompt is required');
+                            }
+                            if (!embedder) {
+                                throw new Error('RAG_EMBEDDER_NOT_CONFIGURED: An embedding provider must be configured ' +
+                                    'to use ragQuery. Set defaultEmbedder in GraphileLlmPreset options.');
+                            }
+                            if (!chatCompleter) {
+                                throw new Error('RAG_CHAT_NOT_CONFIGURED: A chat completion provider must be configured ' +
+                                    'to use ragQuery. Set defaultChatCompleter in GraphileLlmPreset options.');
+                            }
+                            // Resolve parameters with defaults
+                            const limit = queryContextLimit ?? ragDefaults.contextLimit ?? DEFAULT_CONTEXT_LIMIT;
+                            const minSim = queryMinSimilarity ?? ragDefaults.minSimilarity ?? DEFAULT_MIN_SIMILARITY;
+                            const maxDistance = minSim > 0 ? (1 - minSim) : null;
+                            const systemPromptTemplate = querySystemPrompt ?? ragDefaults.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+                            // Step 1: Embed the prompt
+                            const startEmbed = Date.now();
+                            const vector = await embedder(prompt);
+                            const embedLatency = Date.now() - startEmbed;
+                            const vectorString = `[${vector.join(',')}]`;
+                            console.log(`[graphile-llm] RAG embed: dims=${vector.length}, latency=${embedLatency}ms`);
+                            // Step 2: Search chunks tables for similar content
+                            const allChunks = [];
+                            if (chunkTables.length > 0) {
+                                await withPgClient(pgSettings, async (pgClient) => {
+                                    for (const table of chunkTables) {
+                                        const query = buildChunkSearchSql(table, vectorString, limit, maxDistance);
+                                        const result = await pgClient.query(query);
+                                        for (const row of result.rows) {
+                                            allChunks.push({
+                                                content: row.content,
+                                                parent_id: row.parent_id,
+                                                distance: parseFloat(row.distance),
+                                                table_name: table.parentCodecName,
+                                            });
+                                        }
+                                    }
+                                });
+                            }
+                            // Sort by distance (ascending) and take top N
+                            allChunks.sort((a, b) => a.distance - b.distance);
+                            const topChunks = allChunks.slice(0, limit);
+                            if (topChunks.length === 0) {
+                                return {
+                                    answer: 'No relevant context found for your query. ' +
+                                        'Try broadening your search or lowering the minimum similarity threshold.',
+                                    sources: [],
+                                    tokensUsed: null,
+                                };
+                            }
+                            // Step 3: Assemble context
+                            const contextText = assembleContext(topChunks);
+                            // Step 4: Call chat completion
+                            const startChat = Date.now();
+                            const answer = await chatCompleter([
+                                { role: 'system', content: systemPromptTemplate + contextText },
+                                { role: 'user', content: prompt },
+                            ], {
+                                maxTokens: ragDefaults.maxTokens ?? DEFAULT_MAX_TOKENS,
+                            });
+                            const chatLatency = Date.now() - startChat;
+                            console.log(`[graphile-llm] RAG chat: sources=${topChunks.length}, latency=${chatLatency}ms`);
+                            // Step 5: Return response
+                            return {
+                                answer,
+                                sources: topChunks.map((chunk) => ({
+                                    content: chunk.content,
+                                    similarity: 1 - chunk.distance,
+                                    tableName: chunk.table_name,
+                                    parentId: chunk.parent_id,
+                                })),
+                                tokensUsed: null, // Deferred to metering system
+                            };
+                        });
+                    },
+                    embedText(_$root, fieldArgs) {
+                        const $text = fieldArgs.getRaw('text');
+                        return lambda($text, async (text) => {
+                            if (!text || typeof text !== 'string') {
+                                throw new Error('EMBED_INVALID_TEXT: text is required');
+                            }
+                            if (!embedder) {
+                                throw new Error('EMBED_NOT_CONFIGURED: An embedding provider must be configured ' +
+                                    'to use embedText. Set defaultEmbedder in GraphileLlmPreset options.');
+                            }
+                            const startTime = Date.now();
+                            const vector = await embedder(text);
+                            const latencyMs = Date.now() - startTime;
+                            console.log(`[graphile-llm] embedText: dims=${vector.length}, latency=${latencyMs}ms`);
+                            return {
+                                vector,
+                                dimensions: vector.length,
+                            };
+                        });
+                    },
+                },
+            },
+        };
+    });
+    return {
+        ...schemaExtension,
+        name: 'LlmRagPlugin',
+        version: '0.1.0',
+        description: 'RAG (Retrieval-Augmented Generation) query support — ' +
+            'detects @hasChunks tables and adds ragQuery/embedText fields',
+        after: [
+            'LlmModulePlugin',
+            'UnifiedSearchPlugin',
+            'VectorCodecPlugin',
+        ],
+    };
+}

package/esm/plugins/text-mutation-plugin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LlmTextMutationPlugin
+ *
+ * Adds `{columnName}Text: String` companion fields on create/update mutation
+ * inputs for every vector column. When the client provides a text string in
+ * the companion field, the plugin embeds it server-side and injects the
+ * resulting vector into the actual column.
+ *
+ * Example:
+ *   mutation { createArticle(input: { embeddingText: "Machine learning concepts" }) }
+ *
+ * This is the mutation counterpart to LlmTextSearchPlugin (which handles
+ * filter/query-side text-to-vector). Together they let clients work entirely
+ * with text/prompts instead of raw float vectors.
+ *
+ * Runtime embedding uses the v4-style resolver wrapping approach (same as
+ * graphile-upload-plugin and graphile-bucket-provisioner-plugin). grafserv v5
+ * supports this through its backwards-compatibility layer.
+ *
+ * The companion fields are only added when the LLM plugin is loaded.
+ * If no embedder is configured, the fields are still registered for schema
+ * stability but return a clear error at execution time.
+ */
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+declare global {
+    namespace GraphileConfig {
+        interface Plugins {
+            LlmTextMutationPlugin: true;
+        }
+    }
+}
+/**
+ * Creates the LlmTextMutationPlugin.
+ *
+ * Hooks into GraphQLInputObjectType_fields for create/update input types
+ * and adds `{columnName}Text: String` for each vector column.
+ *
+ * Also wraps mutation resolvers via GraphQLObjectType_fields_field to
+ * intercept `*Text` companion field values, embed them, and inject the
+ * resulting vectors before the mutation executes.
+ */
+export declare function createLlmTextMutationPlugin(): GraphileConfig.Plugin;

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

@@ -0,0 +1,191 @@
+/**
+ * LlmTextMutationPlugin
+ *
+ * Adds `{columnName}Text: String` companion fields on create/update mutation
+ * inputs for every vector column. When the client provides a text string in
+ * the companion field, the plugin embeds it server-side and injects the
+ * resulting vector into the actual column.
+ *
+ * Example:
+ *   mutation { createArticle(input: { embeddingText: "Machine learning concepts" }) }
+ *
+ * This is the mutation counterpart to LlmTextSearchPlugin (which handles
+ * filter/query-side text-to-vector). Together they let clients work entirely
+ * with text/prompts instead of raw float vectors.
+ *
+ * Runtime embedding uses the v4-style resolver wrapping approach (same as
+ * graphile-upload-plugin and graphile-bucket-provisioner-plugin). grafserv v5
+ * supports this through its backwards-compatibility layer.
+ *
+ * The companion fields are only added when the LLM plugin is loaded.
+ * If no embedder is configured, the fields are still registered for schema
+ * stability but return a clear error at execution time.
+ */
+import 'graphile-build';
+import 'graphile-build-pg';
+/**
+ * Check if a codec is the pgvector `vector` type.
+ */
+function isVectorCodec(codec) {
+    return codec?.name === 'vector';
+}
+/**
+ * Collect the text→vector field mapping for a codec's vector columns.
+ * Returns a map of textFieldName → vectorFieldName.
+ */
+function getTextToVectorMapping(pgCodec, build) {
+    const mapping = {};
+    if (!pgCodec?.attributes)
+        return mapping;
+    for (const [attributeName, attribute] of Object.entries(pgCodec.attributes)) {
+        if (isVectorCodec(attribute.codec)) {
+            const fieldName = build.inflection.attribute({
+                codec: pgCodec,
+                attributeName,
+            });
+            mapping[`${fieldName}Text`] = fieldName;
+        }
+    }
+    return mapping;
+}
+/**
+ * Creates the LlmTextMutationPlugin.
+ *
+ * Hooks into GraphQLInputObjectType_fields for create/update input types
+ * and adds `{columnName}Text: String` for each vector column.
+ *
+ * Also wraps mutation resolvers via GraphQLObjectType_fields_field to
+ * intercept `*Text` companion field values, embed them, and inject the
+ * resulting vectors before the mutation executes.
+ */
+export function createLlmTextMutationPlugin() {
+    return {
+        name: 'LlmTextMutationPlugin',
+        version: '0.1.0',
+        description: 'Adds text companion fields on mutation inputs for vector columns — ' +
+            'text is embedded server-side before storing',
+        after: [
+            'LlmModulePlugin',
+            'PgAttributesPlugin',
+            'PgMutationCreatePlugin',
+            'PgMutationUpdateDeletePlugin',
+            'VectorCodecPlugin',
+        ],
+        schema: {
+            hooks: {
+                /**
+                 * Add `{columnName}Text: String` fields to create/update input types
+                 * for tables that have vector columns.
+                 */
+                GraphQLInputObjectType_fields(fields, build, context) {
+                    const { scope: { isPgPatch, isPgBaseInput, isMutationInput, pgCodec, }, } = context;
+                    // Only intercept create/update input types for table rows
+                    if (!pgCodec?.attributes || (!isPgPatch && !isPgBaseInput && !isMutationInput)) {
+                        return fields;
+                    }
+                    const { graphql: { GraphQLString }, } = build;
+                    // Find vector columns on this table
+                    const vectorColumns = [];
+                    for (const [attributeName, attribute] of Object.entries(pgCodec.attributes)) {
+                        if (isVectorCodec(attribute.codec)) {
+                            vectorColumns.push(attributeName);
+                        }
+                    }
+                    if (vectorColumns.length === 0) {
+                        return fields;
+                    }
+                    let newFields = fields;
+                    for (const columnName of vectorColumns) {
+                        // Convert snake_case column name to camelCase field name
+                        const fieldName = build.inflection.attribute({
+                            codec: pgCodec,
+                            attributeName: columnName,
+                        });
+                        const textFieldName = `${fieldName}Text`;
+                        newFields = build.extend(newFields, {
+                            [textFieldName]: {
+                                type: GraphQLString,
+                                description: `Natural language text to embed server-side into the \`${fieldName}\` vector column. ` +
+                                    `Mutually exclusive with \`${fieldName}\` — provide one or the other. ` +
+                                    'Requires the LLM plugin to be configured with an embedding provider.',
+                            },
+                        }, `LlmTextMutationPlugin adding ${textFieldName} companion field for vector column '${columnName}'`);
+                    }
+                    return newFields;
+                },
+                /**
+                 * Wrap create/update mutation resolvers to intercept `*Text` companion
+                 * field values, embed them using the configured embedder, and inject
+                 * the resulting vector into the corresponding vector field.
+                 *
+                 * Uses the same v4-style resolver wrapping pattern as graphile-upload-plugin
+                 * and graphile-bucket-provisioner-plugin. grafserv v5 supports this through
+                 * its backwards-compatibility layer.
+                 */
+                GraphQLObjectType_fields_field(field, build, context) {
+                    const { scope: { isRootMutation, fieldName, pgCodec }, } = context;
+                    // Only wrap root mutation fields on tables with attributes
+                    if (!isRootMutation || !pgCodec || !pgCodec.attributes) {
+                        return field;
+                    }
+                    // Only wrap create/update mutations
+                    const isCreate = fieldName.startsWith('create');
+                    const isUpdate = fieldName.startsWith('update');
+                    if (!isCreate && !isUpdate) {
+                        return field;
+                    }
+                    // Build the text→vector mapping for this codec
+                    const textToVectorMap = getTextToVectorMapping(pgCodec, build);
+                    if (Object.keys(textToVectorMap).length === 0) {
+                        return field;
+                    }
+                    const embedder = build.llmEmbedder;
+                    const defaultResolver = (obj) => obj[fieldName];
+                    const { resolve: oldResolve = defaultResolver, ...rest } = field;
+                    return {
+                        ...rest,
+                        async resolve(source, args, graphqlContext, info) {
+                            // Walk through the input args and embed any *Text companion fields
+                            async function embedTextFields(obj) {
+                                if (!obj || typeof obj !== 'object')
+                                    return;
+                                const pending = [];
+                                for (const key of Object.keys(obj)) {
+                                    const value = obj[key];
+                                    // Check if this key is a *Text companion field
+                                    if (key in textToVectorMap && typeof value === 'string') {
+                                        const vectorFieldName = textToVectorMap[key];
+                                        pending.push((async () => {
+                                            if (!embedder) {
+                                                throw new Error(`EMBED_NOT_CONFIGURED: Cannot embed ${key} — no embedding provider configured. ` +
+                                                    'Set defaultEmbedder in GraphileLlmPreset options or EMBEDDER_PROVIDER env var.');
+                                            }
+                                            const startTime = Date.now();
+                                            const vector = await embedder(value);
+                                            const latencyMs = Date.now() - startTime;
+                                            console.log(`[graphile-llm] Mutation embed: field=${key}, dims=${vector.length}, latency=${latencyMs}ms`);
+                                            // Inject the vector into the corresponding field
+                                            obj[vectorFieldName] = vector;
+                                            // Remove the consumed *Text field
+                                            delete obj[key];
+                                        })());
+                                        continue;
+                                    }
+                                    // Recurse into nested objects (e.g. input.article.embeddingText)
+                                    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                                        pending.push(embedTextFields(value));
+                                    }
+                                }
+                                if (pending.length > 0) {
+                                    await Promise.all(pending);
+                                }
+                            }
+                            await embedTextFields(args);
+                            return oldResolve(source, args, graphqlContext, info);
+                        },
+                    };
+                },
+            },
+        },
+    };
+}

package/esm/plugins/text-search-plugin.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+import type { GraphileConfig } from 'graphile-config';
+declare global {
+    namespace GraphileConfig {
+        interface Plugins {
+            LlmTextSearchPlugin: true;
+        }
+    }
+}
+/**
+ * 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 declare function createLlmTextSearchPlugin(): GraphileConfig.Plugin;