Quickstart

bunx unrag@latest init --yes --store drizzle --dir lib/unrag --alias @unrag

# Your Postgres connection string
DATABASE_URL="postgresql://user:password@localhost:5432/mydb"

# API key for embedding (required by the AI SDK)
AI_GATEWAY_API_KEY="your-openai-api-key"

AI_GATEWAY_MODEL="openai/text-embedding-3-large"

-- Enable pgvector
create extension if not exists vector;

-- Create tables
create table documents (
  id uuid primary key,
  source_id text not null unique,
  content text not null,
  metadata jsonb,
  created_at timestamp default now()
);

create table chunks (
  id uuid primary key,
  document_id uuid not null references documents(id) on delete cascade,
  source_id text not null,
  idx integer not null,
  content text not null,
  token_count integer not null,
  metadata jsonb,
  created_at timestamp default now()
);

create table embeddings (
  chunk_id uuid primary key references chunks(id) on delete cascade,
  embedding vector,
  embedding_dimension integer,
  created_at timestamp default now()
);

-- Add indexes for common queries
create index if not exists chunks_source_id_idx on chunks(source_id);
create index if not exists documents_source_id_idx on documents(source_id);
-- Recommended for vector search performance (pgvector 0.5.0+):
create index if not exists embeddings_hnsw_idx
on embeddings using hnsw (embedding vector_cosine_ops);

import { createUnragEngine } from "@unrag/config";

async function ingestDemo() {
  const engine = createUnragEngine();

  // Ingest a piece of content
  const result = await engine.ingest({
    sourceId: "docs:quickstart",
    content: `
      Unrag is a RAG installer for TypeScript projects. It installs a small,
      composable module into your codebase as vendored source files. Instead
      of depending on an external SDK, you own the code and can modify it
      to fit your needs.
      
      The two core operations are ingest and retrieve. Ingestion takes content,
      splits it into chunks, generates embeddings for each chunk, and stores
      everything in Postgres with pgvector. Retrieval takes a query, embeds it,
      and finds the most similar chunks using vector similarity search.
    `,
    metadata: { 
      section: "getting-started",
      language: "en" 
    },
  });

  console.log("Ingested document:", result.documentId);
  console.log("Created chunks:", result.chunkCount);
  console.log("Embedding model:", result.embeddingModel);
  console.log("Timings:", result.durations);
}

ingestDemo().catch(console.error);

import { createUnragEngine } from "@unrag/config";

async function retrieveDemo() {
  const engine = createUnragEngine();

  const result = await engine.retrieve({
    query: "What are the core operations in Unrag?",
    topK: 5,
  });

  console.log("Found", result.chunks.length, "chunks");
  console.log("Embedding model:", result.embeddingModel);
  console.log("Timings:", result.durations);
  
  for (const chunk of result.chunks) {
    console.log("\n---");
    console.log("Score:", chunk.score);
    console.log("Source:", chunk.sourceId);
    console.log("Content:", chunk.content.substring(0, 200) + "...");
  }
}

retrieveDemo().catch(console.error);