Embrix for Node.js and TypeScript

Embrix is a local-first AI application toolkit for JavaScript runtimes.

It gives Node.js and TypeScript projects a clean set of primitives for:

• vector storage and semantic search
• multi-step stateful workflows
• tool-using agents
• retrieval-augmented generation
• database vectorization and search
• bring-your-own model providers

Installation

npm install embrix-node

Install the drivers or provider SDKs you actually use:

npm install better-sqlite3
npm install openai
npm install pg
npm install mysql2
npm install mongodb

What the Node package includes

| Component | Purpose | | -------------------------------- | ------------------------------------------------------------ | | VectorStore | Local vector persistence and similarity search | | StateGraph | State-based workflow execution | | Agent | Tool-using agents with iterative reasoning | | RAGPipeline | Retrieval plus grounded response generation | | DBVectorizer + DBQueryEngine | Database row vectorization, semantic search, and text-to-SQL |

Quick start

Vector storage

import { VectorStore } from "embrix-node";

const store = new VectorStore({ dbPath: "embrix.db", dimension: 3 });

store.upsert("docs", [
  {
    id: "intro",
    values: [0.1, 0.2, 0.3],
    text: "Embrix helps you build local-first AI features.",
    metadata: { topic: "overview" },
  },
]);

const results = store.query("docs", [0.1, 0.2, 0.3], 1);
console.log(results);

Stateful workflow

import { END, START, StateGraph } from "embrix-node";

type WorkflowState = { question: string; context?: string; answer?: string };

const graph = new StateGraph<WorkflowState>();
graph.addNode("retrieve", (state) => ({
  ...state,
  context: `facts for ${state.question}`,
}));
graph.addNode("respond", (state) => ({
  ...state,
  answer: `Answer from ${state.context}`,
}));
graph.addEdge(START, "retrieve");
graph.addEdge("retrieve", "respond");
graph.addEdge("respond", END);

const result = await graph.compile().invoke({ question: "What is retrieval?" });
console.log(result.answer);

Agent with your own provider

import {
  Agent,
  OpenAICompatibleChatModel,
  Tool,
} from "embrix-node";

const calculator = new Tool(
  "calculator",
  "Evaluate arithmetic expressions",
  async (input) => {
    return String(Function(`return (${input})`)());
  },
);

const agent = new Agent({
  tools: [calculator],
  llm: new OpenAICompatibleChatModel({
    model: "gpt-4o-mini",
    apiKey: process.env.OPENAI_API_KEY,
  }),
});

console.log(
  await agent.run("Use the calculator tool to compute (12 * 9) + 4."),
);

RAG pipeline

import {
  OpenAIEmbedder,
  RAGPipeline,
  VectorStore,
  createChatModel,
} from "embrix-node";

const store = new VectorStore({ dbPath: "rag.db", dimension: 1536 });
const embedder = new OpenAIEmbedder({ apiKey: process.env.OPENAI_API_KEY! });
const llm = createChatModel("ollama", { model: "llama3.1" });

const rag = new RAGPipeline(embedder, llm, store);
await rag.ingest(
  ["Embrix supports search, workflows, agents, and database tooling."],
  "docs",
);

console.log(await rag.query("What does Embrix support?", "docs"));

Database search and querying

import {
  DBQueryEngine,
  DBVectorizer,
  OpenAIEmbedder,
  VectorStore,
  dbConnect,
  createChatModel,
} from "embrix-node";

const connector = dbConnect("sqlite", { dbPath: "products.db" });
const embedder = new OpenAIEmbedder({ apiKey: process.env.OPENAI_API_KEY! });
const store = new VectorStore({
  dbPath: "products-vectors.db",
  dimension: 1536,
});

const vectorizer = new DBVectorizer(connector, embedder, { store });
await vectorizer.vectorizeTable("products", "products", {
  textColumns: ["name", "description"],
});

const engine = new DBQueryEngine(vectorizer, undefined, {
  connector,
  llm: createChatModel("openai-compatible", {
    model: "gpt-4o-mini",
    apiKey: process.env.OPENAI_API_KEY,
  }),
});

console.log(await engine.search("budget running shoes", "products"));
console.log(
  await engine.sqlQuery("Show products under 100 dollars", "products"),
);

Provider model

Embrix does not run its own hosted model platform.

Instead, you connect the package to your own provider, gateway, or local runtime.

Built-in options include:

• OpenAICompatibleChatModel
• AnthropicChatModel
• GeminiChatModel
• OllamaChatModel
• CustomChatModel

This makes the Node package flexible for production services, local tools, internal gateways, and offline-friendly experiments.

Typical use cases

• internal knowledge tools
• API backends with retrieval and workflow steps
• local prototypes and desktop utilities
• semantic search over app data
• plain-language database exploration
• agent-driven automation with custom tools

Development

cd embrix-node
npm install
npm run build

License

MIT