Document API live · realtime, RLS & vectors rolling out

The data and memory layer for AI apps.

Store documents, search by meaning, and stream changes in real time. It all lives behind one Postgres-backed API, scoped to your users with the auth provider you already use.

1 query: vector + filter + RLS
Bring: your own auth
1 API: one bill, not three

search.ts

preview

// One query: vector similarity + JSONB filter + your user's access scope.
const { data } = await gresiq
  .collection("memories")
  .where({ lang: "fa" })             // JSONB metadata filter
  .nearest(embedding, { limit: 10 }) // pgvector ANN search
  .run();                            // row-level security applied automatically

One query, four powers

Vector, metadata, full-text, and access control in a single Postgres query.

Pinecone bolts metadata filtering on after the fact and leaves auth to you. GresIQ pushes all four into one query plan, so results come back already filtered, ranked, and scoped to the end user.

hybrid-search.ts

preview

// One query: vector similarity + JSONB filter + your user's access scope.
const { data } = await gresiq
  .collection("memories")
  .where({ lang: "fa" })             // JSONB metadata filter
  .nearest(embedding, { limit: 10 }) // pgvector ANN search
  .run();                            // row-level security applied automatically

1.collection("memories")
Documents. A schemaless JSONB collection. Adding a field takes no migration.
2.where({ lang: "fa" })
Metadata filter. Filter on any JSONB key. Indexed, not bolted on after the fact.
3.nearest(embedding, { limit: 10 })
Vector search. pgvector approximate-nearest-neighbour, ranked by meaning.
4.run()
Row-level security. The end user's token scopes every row, so you never post-filter in your app.

Why GresIQ

The backend for AI apps, without the sprawl.

Five capabilities that usually mean five vendors. Here they're one service, built on a database you already trust.

One query, four powers

Vector similarity, JSONB metadata filters, full-text search, and per-user row-level security resolve together in a single Postgres query, instead of four round trips you reconcile by hand.

Bring your own auth

GresIQ verifies JWTs from Auth0, Clerk, Firebase, Cognito, or smbCloud Auth via JWKS. You keep your users and you keep your identity vendor.

Documents, realtime, and vectors behind one API

A schemaless JSONB store, change subscriptions, and vector search behind one endpoint and one bill, instead of three services to integrate and keep in sync.

Inference-free by default

Bring your own embeddings and keep full control of your model and your cost. Or opt into edge-computed embeddings when you'd rather not run them yourself.

Postgres underneath

Real transactions, a SQL escape hatch when you need it, and no proprietary data format. Your data stays portable.

Bring your own auth

Keep the identity provider you already use.

GresIQ verifies the user's JWT against your provider's JWKS, then row-level security scopes every row to that user. You don't migrate users, and you never get locked into one identity vendor.

Auth0
Clerk
Firebase
Cognito
smbCloud Auth

client.ts

preview

// Use the identity provider you already have: Auth0, Clerk, Firebase,
// or smbCloud Auth. GresIQ verifies the JWT via JWKS; RLS scopes the data.
const gresiq = createClient("https://api.gresiq.com", { token: userJwt });

terminal

curl https://api.gresiq.com/gresiq/v1/collections/memories \
  -H "Authorization: Bearer $USER_JWT" \
  -H "X-Gresiq-Api-Key: $GRESIQ_KEY"

How it works

From zero to a scoped query in three steps.

Create a collection

Declare a JSONB collection and its vector dimensions. No schema to design up front.

preview

// 1. Create a collection
await gresiq.collections.create("memories", {
  vector: { dimensions: 1536 },
});

Write documents

Insert documents with any shape, plus an embedding. Add fields whenever you want, with no migration to run.

preview

// 2. Write documents (schemaless JSONB + an embedding)
await gresiq.collection("memories").insert({
  text: "Rumi on the reed flute",
  lang: "fa",
  embedding,
});

Query scoped to your user

Pass the end user's token. GresIQ applies row-level security and returns only their data.

preview

// 3. Query, scoped to your end user's token
const gresiq = createClient(API_URL, { token: userJwt });
const { data } = await gresiq
  .collection("memories")
  .nearest(embedding, { limit: 5 })
  .run();

Postgres underneath · no lock-in

ACID transactions

Real consistency, not eventual hand-waving.

SQL escape hatch

Drop to raw SQL the moment you need it.

No proprietary format

Standard Postgres. Your data stays portable.

Battle-tested

Decades of tooling, backups, and operators.

GresIQ vs. DIY

One service, or three you wire together yourself.

The DIY stack (a document store, a vector database, and an auth provider) is a great way to ship. GresIQ gives you the same capabilities with fewer moving parts to integrate, bill, and reconcile.

Capability	GresIQ	DIY: Supabase + Pinecone + Auth0
Services to integrate	One API	Three (store + vectors + auth)
Hybrid query (vector + filter + RLS)	Single query	Stitched across services
Billing	One bill	Three invoices
Identity provider	Bring your own (JWKS)	Per-service wiring
Data store	Postgres + JSONB	Postgres + a separate vector DB
Vendor lock-in	Standard Postgres, SQL escape hatch	Proprietary vector format

Comparison reflects GresIQ's intended feature set. Some capabilities are rolling out. See the roadmap below.

Roadmap

Honest about where we are.

The document store is the live foundation. The rest is rolling out, and we'd rather show you the real status than fake general availability.

Live now

Document API
Schemaless JSONB collections over HTTP. Create, write, and read documents today.

Coming soon

Realtime subscriptions
Stream inserts and updates to your clients as they happen.
Row-level security
Per-user data scoping enforced in the database from the end user's token.
Vector search
pgvector ANN search and hybrid queries that fuse vectors, filters, and RLS.
Client SDKs
First-class JavaScript / TypeScript and Swift clients.

Build your AI backend on one API.

Join the waitlist for early access. We'll reach out as realtime, RLS, and vector search land.

Part of smbCloud Platform