Key facts
| RAG endpoints | POST /v1/embeddings, POST /v1/rag/collections and POST /v1/rag/query |
| Embedding models | plugsky-embed-v1 (1536 dimensions, OpenAI-ada compatible) and plugsky-embed-large (3072 dimensions) |
| Retrieval modes | Keyword, vector and hybrid search with optional cross-encoder reranking |
| Citations | Every query returns ranked chunks with source attribution |
| Ingestion | Documents are chunked, embedded and indexed automatically per collection |
| Batch limits | Up to 2,048 inputs per embeddings request, max 8,191 tokens each |
| Data handling | Per-collection encryption at rest; API data is not used to train models |
| Deployment | Hosted, VPC, on-prem and air-gapped options; 30+ models behind one API |
TL;DR
- Embed, store and query with three OpenAI-compatible endpoints.
- Use managed collections for speed, or standalone embeddings with your own vector store.
- Batch up to 2,048 inputs per request at 8,191 tokens each.
- Compare vector-only and hybrid retrieval on a real evaluation set before shipping.
- Prototype on the free plan, then scale when retrieval quality holds.
How it works, step by step
- Chunk a sample corpus and create a collection with POST /v1/rag/collections.
- Ingest documents and confirm chunking matches the document structure.
- Query with POST /v1/rag/query and inspect top_k results and citation sources.
- Switch between vector, keyword and hybrid modes to find the best recall.
- Add reranking and re-run the evaluation set to measure the difference.
- Move to production with scoped keys per environment and audit logging.
- Re-embed only when the embedding model changes; keep model names pinned in config.
Original data
Try it yourself
Why developers need RAG grounded in their own content
The shortest path from documents to answers is: chunk the source, embed the chunks, store them, then retrieve the best matches for each question and pass them to a chat model. Plugsky gives you that loop as managed endpoints instead of a weekend of glue code, and the client is the OpenAI SDK you already have — just point base_url at https://api.plugsky.com/v1.
You still make the decisions that matter: chunk size for your document type, which retrieval mode fits the queries, how many chunks top_k should return, and what your evaluation set looks like before you ship.
The Plugsky RAG stack: embeddings, collections, queries
Plugsky collapses the usual multi-vendor RAG stack into three OpenAI-compatible endpoints: POST /v1/embeddings turns text into vectors, POST /v1/rag/collections creates and manages collections, and POST /v1/rag/query returns ranked chunks with citations. Ingestion is automatic — documents are chunked, embedded and indexed per collection — and retrieval supports keyword, vector and hybrid modes with optional cross-encoder reranking. The embedding models are plugsky-embed-v1 (1536 dimensions, OpenAI-ada compatible) and plugsky-embed-large (3072 dimensions). For developers the useful part is that the same SDK and auth work here as everywhere else, so the retrieval path is code you write once rather than a platform you operate.
The controls developers should configure first
There are two integration paths. Managed collections are fastest: create a collection, ingest documents, query, and take chunks with citations — Plugsky handles chunking, indexing and encryption. The standalone path suits teams that already run pgvector, Pinecone, Qdrant or another store: call POST /v1/embeddings and keep retrieval in your own code.
The endpoint accepts arrays of inputs, up to 2,048 strings per request at a maximum of 8,191 tokens each, so large corpora need client-side batching. Because the embeddings format is OpenAI-compatible, switching between the managed and self-managed paths is not a rewrite.
A practical pilot path
Before shipping, build a small evaluation set of questions and expected source documents, then compare vector-only search against hybrid with reranking. Watch retrieval recall first — a fluent answer built on the wrong chunk is worse than no answer — and only then tune prompts and model choice. The free plan includes plugsky-micro and plugsky-lite, so you can prototype end to end at no cost. See the live pricing page for current plans.
Honest comparison
| Capability | Plugsky | Assembling your own stack | Keyword search only |
|---|---|---|---|
| Retrieval | Keyword, vector and hybrid with optional reranking | You integrate and tune each component | Keyword matching, no semantics |
| Citations | Ranked chunks with source attribution | You build attribution yourself | Document links, not passages |
| Embeddings | plugsky-embed-v1 (1536d) and plugsky-embed-large (3072d) | Model choice spread across vendors | Not applicable |
| Deployment | Hosted, VPC, on-prem and air-gapped | Depends on every component | Usually on-prem already |
| Data handling | Per-collection encryption; API data not used to train models | You audit every vendor | Existing controls apply |
| Time to first answer | One collection and a query call | Weeks of integration work | Days, with lower answer quality |
Frequently asked questions
Can I use my own vector database?
Yes. Call the embeddings endpoint standalone and store vectors in pgvector, Pinecone, Qdrant or any other store; the OpenAI-compatible format works with existing tooling.
Where can I try RAG before writing code?
Open the RAG sandbox to create a collection, ingest a document and query it in the browser, then copy the same calls into your application.
Do we have to change our application code?
No. The RAG endpoints are OpenAI-compatible, so existing SDKs, prompts and evaluation harnesses keep working when you point the base URL at Plugsky.
Is there a free plan?
Yes — plugsky-micro and plugsky-lite with 2 API keys and no credit card. A 14-day full-access trial is also available.
How is pricing structured?
Self-serve plans are flat monthly with unlimited fair-use usage and no per-token charges or overage fees. See the live pricing page for current plans.
Does Plugsky train on our data?
Plugsky states that API data is not used to train models, and collections are encrypted at rest; on Enterprise you can keep everything inside your own VPC.