Search & AI

Two capabilities ship today: full-text search (configured per-entity) and a built-in LLM proxy (configured by env). Neither is enabled through a manifest.plugins list.

`search`

Full-text search backed by SQLite’s FTS5 (or Postgres tsvector on Postgres). You configure it on the entity, not as a plugin. A search config creates FTS5 + facet-bitmap shadow tables on schema push. Pylon maintains them on every write. Declare it with the builder’s .search({...}) (or the search key in the entity options):

import { e, field } from "@pylonsync/sdk";

export const Post = e.entity("Post", {
  title:    field.string(),
  body:     field.string(),
  tags:     field.string(),
  authorId: field.string(),
  viewCount: field.int(),
}).search({
  text:     ["title", "body"],   // tokenized into the FTS5 index
  facets:   ["authorId", "tags"], // materialized as facet bitmaps
  sortable: ["viewCount"],        // indexed for stable pagination
});

Key	Purpose
`text`	Fields tokenized into the FTS5 index for keyword matching
`facets`	Fields materialized as bitmaps for instant per-value counts
`sortable`	Fields indexed so result sets paginate stably

Query via POST /api/search/<Entity>, or the React hook:

const { hits, facetCounts, total, loading } = db.useSearch<Post>("Post", {
  query: input,
  facets: ["tags"],
});

facetCounts is the live count per facet value over the current filtered hit set. It is enough to build Algolia-style faceted UIs without Algolia.

LLM proxy

A built-in proxy to LLM providers so your API key stays server-side and clients never see it. Environment variables configure it, not a plugin entry. Two endpoints, both requiring an authenticated session:

POST /api/llm/complete — non-streaming completion.
POST /api/ai/stream — SSE streaming completion.

And, inside a mutation or action, ctx.llm.complete(...) / ctx.llm.stream(...) (server-only; the key never reaches the client, and neither is available in queries).

`ctx.llm.stream`

complete resolves when the model finishes. stream calls your handler for each event as the provider emits it, then resolves with the same assembled response. You can push text to the client while it generates and still branch on stop_reason afterwards:

const res = await ctx.llm.stream(
  { messages, tools },
  (e) => {
    if (e.type === "text_delta") ctx.stream.write(e.text);
  },
);
if (res.stop_reason === "tool_use") { /* run the tools, loop */ }

Events are text_delta {text}, tool_use_start {id, name}, tool_input_delta {partial_json}, and done {stop_reason, usage}. Tool arguments arrive as raw JSON fragments. Concatenate them and parse once at the end. Same auth gate and same model allowlist as complete: streaming cannot reach a model complete would refuse. Streaming does not extend the call deadline (PYLON_FN_CALL_TIMEOUT, 30s default), so a long agent run must declare timeout: <seconds> on the function. To reach every client watching rather than only the caller, push the same deltas through ctx.rooms.broadcast. Full walkthrough, including an agent tool loop: Functions → Streaming LLM output.

Env

# /api/llm/complete, ctx.llm.complete, ctx.llm.stream
PYLON_LLM_PROVIDER=anthropic          # anthropic | openai
ANTHROPIC_API_KEY=sk-ant-...          # or OPENAI_API_KEY for openai

# /api/ai/stream (SSE)
PYLON_AI_PROVIDER=anthropic           # anthropic | openai | custom
PYLON_AI_API_KEY=sk-ant-...
PYLON_AI_MODEL=claude-sonnet-4-5
PYLON_AI_BASE_URL=https://...         # required for provider "custom"

Model allowlist

Clients may request a specific model on /api/ai/stream only if it’s allowlisted — otherwise the request is rejected with MODEL_NOT_ALLOWED. Set the allowlist via the manifest llm() helper or PYLON_AI_MODELS_ALLOWED:

import { buildManifest, llm } from "@pylonsync/sdk";

buildManifest({
  name: "myapp",
  llm: llm({ allowedModels: ["claude-sonnet-4-5", "claude-haiku-4-5"] }),
  // ...
});

Why proxy:

API keys stay server-side: browser / native clients never see them.
Auth-gated: both endpoints require a session.
Model allowlist: cap which models clients can invoke.

Vector search

Built in as a field type, not a plugin. Declare embedding: field.vector(1536) on an entity, fill it with ctx.llm.embed(texts) (OpenAI or Voyage), and query with ctx.db.vectorSearch(entity, { field, vector, limit, filter }) or POST /api/vector-search/<Entity>. Exact k-NN, cosine by default, both backends. Full guide: Vector Search.

Not yet built in

MCP server: exposing your entities/functions as Model Context Protocol tools as a manifest plugin is planned, not shipped. The CLI’s pylon mcp (agent tooling) exists today.

Do not build against unshipped plugins until they ship.

Get started

Core concepts

SSR

Auth

Plugins

Clients

Operations

Compare

Migrate

`search`

LLM proxy

`ctx.llm.stream`

Env

Model allowlist

Vector search

Not yet built in

​search

​LLM proxy

​ctx.llm.stream

​Env

​Model allowlist

​Vector search

​Not yet built in

`search`

LLM proxy

`ctx.llm.stream`

Env

Model allowlist

Vector search

Not yet built in