Capabilities

Everything an AI feature needs,
behind one door

Model routing, retrieval, tools, memory, safety and observability — configured as data per project, never forked into branched code.

Model orchestration · BYOK

Pick model, temperature and response format per project. Bring your own key for any provider — OpenAI, Anthropic, Google and more. Keys stay yours; swap providers without a rewrite.

Knowledge base (RAG)

Ingest documents, chunk and embed with pgvector, and retrieve the right context automatically — scoped strictly to the tenant.

Tools & endpoints

Conversation memory

Stateful threads with full turn history. Bring your own conversation id with externalThreadId — no UUID round-trips.

Safety & compliance

Prompt-injection detection, compliance guard and incident logging. Defense in depth — no single failure mode takes the system down.

True multi-tenancy

Every row, read and cache key is scoped by tenant. There is no global data path that bypasses isolation.

Extensions

Pluggable behaviour modules — cost, performance, eco-mode, safety — register on named lifecycle hooks without forking the core.

Personality & prompts

Versioned system prompts and per-project personality, composed into the right prompt for each intent.

Quota & rate limits

Per-tenant quota and rate limiting keep noisy neighbours and runaway costs contained automatically.

For developers

Integrate in one call — from any stack

A typed Node SDK, raw HTTP, streaming, and an MCP server for editor-native admin. Every response follows one envelope: { status, data } on success, a closed error enum on failure.

Official @ego-z/client SDK — TypeScript-first, automatic retries
Streaming via callback (askStream) or for-await (askStreamIter)
Trusted-header passthrough into per-tool forwardHeaders
Express middleware for webhook signature verification
@ego-z/mcp — manage tools & knowledge base from Cursor

Read the docs View pricing

stream.ts

// Token-by-token streaming
for await (const chunk of egoz.askStreamIter({
  message: 'Check my order status',
  externalThreadId: 'conv:abc123',
  headers: { authorization: userToken },
})) {
  process.stdout.write(chunk.delta);
}

POST /egoz/ask

# Any language, one endpoint
curl -X POST https://api.egoz.dev/egoz/ask \
  -H "X-API-Key: $EGOZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "tenantId": "...", "message": "Hi" }'

The request lifecycle

The eight steps inside every `/ask`

Authenticate & resolve tenant

Nothing touches data before EgoZ knows whose isolated path it's on.

Load tenant context

Config, enabled tools, knowledge-base scope, prompt overrides, extensions.

Load conversation state

Prior turns from the thread — by EgoZ id or externalThreadId.

Classify intent

vanilla / RAG / tools / RAG+tools — cheap, deterministic, language-agnostic.

Assemble context

History + retrieved chunks + tool catalog, exactly as the intent needs.

Call the LLM

The right model and system prompt for the classified intent.

Execute tools safely

Dedup, per-tool caps, error classification, transient retry, iteration cap.

Persist & return

Message, token usage, intent and audit flags — then a rich response payload.

Everything an AI feature needs,behind one door