Reference

This is the exhaustive enumeration layer of the memQL documentation: the dense, grouped lists that the conceptual and how-to docs point into. It catalogs every concept (the schemas), every tool (the SI-callable surface), every provider (the SI vendor/model records), every routing policy, and every builtin (Go-backed DSL functions) currently shipped in the dsl/ tree of the public memQL repository.

This is the most drift-prone document in the set. It is a hand-verified snapshot of the dsl/ tree on the current main branch. Counts and descriptions are copied from the @description annotations in the source .memql files. When the DSL tree changes, regenerate this page from dsl/*/concepts.memql, dsl/*/tools*.memql, dsl/providers/providers.memql, dsl/policies/policies.memql, and dsl/*/builtins.memql. Where a count or claim could not be confirmed against source, it is marked inline.

#How the DSL tree is organized

The public repo uses a flat per-namespace layout (one directory per namespace, with per-construct files inside it), not the nested dsl/v1/<type>/v1/<namespace>/ layout described in some internal docs:

dsl/<namespace>/concepts.memql      # all concepts in the namespace
dsl/<namespace>/tools.memql         # all tools (or dsl/<namespace>/tools/*.memql)
dsl/<namespace>/builtins.memql      # all builtins in the namespace
dsl/providers/providers.memql       # all SI providers (single file)
dsl/policies/policies.memql         # all SI Router routing policies (single file)

Each concepts.memql carries file-level @version and @namespace annotations; an individual construct's canonical id is composed as v{major}:{namespace}:{conceptName}. For example, the agent concept in dsl/agents/concepts.memql (@namespace("agents"), @version("1.0.0")) is addressed canonically as v1:agents:agent.

// dsl/agents/concepts.memql (header)
@version("1.0.0")
@namespace("agents")

#A note on @scope

Internal narrative in several @description strings refers to concepts being "global-scoped" (living in the reserved _system partition). However, the canonical reference doc dsl/_reference/_concept.memql states that the @scope("global") annotation was retired in the partition-removal pivot (section 5: "Authoring a @scope annotation on a concept is a load-time error"). That same reference file is internally inconsistent — a later section (13) still documents @scope("global") and a worked example uses it. No concepts.memql file in the tree carries a live @scope annotation. Treat the "global-scoped" language in concept descriptions below as historical intent, not a confirmed runtime property. (File: dsl/_reference/_concept.memql.)

#Concepts (101 total, 22 namespaces)

Concepts are schemas for time-series nodes — the base of the DSL dependency tree; every other construct references one or more concept ids. The one-line summaries below are condensed from each concept's @description. Source files: dsl/<namespace>/concepts.memql.

#agents — dsl/agents/concepts.memql

#calendar — dsl/calendar/concepts.memql

#cluster — dsl/cluster/concepts.memql

#cognition — dsl/cognition/concepts.memql

#common — dsl/common/concepts.memql

#curriculum — dsl/curriculum/concepts.memql

#data — dsl/data/concepts.memql

#guide — dsl/guide/concepts.memql

#harness — dsl/harness/concepts.memql

#identity — dsl/identity/concepts.memql

#knowledge — dsl/knowledge/concepts.memql

#library — dsl/library/concepts.memql

#memql — dsl/memql/concepts.memql

#notes — dsl/notes/concepts.memql

#observability — dsl/observability/concepts.memql

#planner — dsl/planner/concepts.memql

#platform — dsl/platform/concepts.memql

#router — dsl/router/concepts.memql

#safety — dsl/safety/concepts.memql

#todos — dsl/todos/concepts.memql

#workbench — dsl/workbench/concepts.memql

#worker — dsl/worker/concepts.memql

#Tools (24 total)

Tools are the SI-callable surface — the discoverable, schema-typed entry points an agent's tool loop binds call args to. Each tool declares a @handler (the function it forwards to) and an @executionTime hint (fast or medium). The tool body is its input schema (a field list with types and @required/@default/@description annotations).

Handler types observed: type="query" (15 tools — forward to a query or mutation function) and type="function" (9 tools — forward to a named Go-backed function handler). Execution times observed: fast (20) and medium (4).

A representative tool body, copied from source:

@handler(type="query", query="mutationCreateCalendarEvent({...})")
@executionTime("fast")
@description("Create a native calendar event for the caller...")
tool calendarCreate {
  title       string  @required @description("Event title, e.g. 'Karate class'.")
  startsAt    string  @required @description("Event start as an RFC3339 timestamp.")
  endsAt      string  @description("Event end as an RFC3339 timestamp. Omit for a point-in-time reminder.")
  allDay      boolean @default("false") @description("True for a date-scoped all-day event.")
  location    string  @description("Free-form location text.")
  notes       string  @description("Free-form notes / description.")
  recurrence  string  @description("Optional RFC-5545 RRULE recurrence rule.")
}

File: dsl/calendar/tools.memql.

#calendar — dsl/calendar/tools.memql

#memql — dsl/memql/tools.memql

#notes — dsl/notes/tools.memql

#todos — dsl/todos/tools.memql

#agents — dsl/agents/tools/*.memql

#cognition — dsl/cognition/tools/recentChat.memql

#Providers (57 total, single file)

Providers are SI vendor + model + auth records. They come in two forms:

• Base providers (@base + @type) carry vendor-level auth and type. There are 6: anthropic, google, groq, mistral, openai, xai.
• Model providers (@extends("<base>") + @model + optional @type) declare a concrete model, optional @description, and a params block (context window, completion-token cap, cost-per-million).

The default chat provider is stream54 (carries the @default annotation — "every caller that does not explicitly pick a provider lands here"). Source file: dsl/providers/providers.memql.

A representative model provider with its params block:

@extends("openai")
@model("gpt-5.4-mini")
@description("OpenAI GPT-5.4 Mini - balanced cost/latency chat (non-streaming)")
provider chat54Mini {
  params {
    contextWindow              128000
    maxCompletionTokens        16384
    inputCostPerMillion        0.15
    outputCostPerMillion       0.60
    cachedInputCostPerMillion  0.075
  }
}

File: dsl/providers/providers.memql.

#Base providers

#Model providers

Grouped by capability. Each row lists the provider name, its @model, and the @type where one is declared (model providers that only set @extends inherit the base @type).

#Chat — non-streaming

#Chat — streaming (@type ends in Stream)

#Embedding (@type OpenAIEmbedding)

#Speech-to-text (@type OpenAISTT)

#Text-to-speech (@type OpenAITTS)

#Audio / realtime / multimodal (placeholder types — clients not yet landed)

The descriptions on these note "Placeholder type until the … client lands."

#Policies (5 total — SI Router routing policies)

The policies that ship in the public dsl/ tree are SI Router routing policies (block syntax: @primary / @fallback / latency knobs). They select which provider serves a given workload and define a fallback chain. Source file: dsl/policies/policies.memql.

Scope note. The internal CLAUDE.md describes a second, distinct policy system — cross-cutting decision policies (func (Policy) name(ctx) { ... } with @tier / @frontend_visible / @audited annotations, under dsl/policies/core/ and dsl/policies/bff/). No such decision policies exist in this repo's dsl/ tree. The only func (Policy) references are in the documentation/reference files (dsl/_reference/_trait.memql). The v1:platform:policyTrace concept and the EvaluatePolicy engine path exist, but the public DSL ships only the five routing policies below.

Routing-policy fields:

• @primary("<provider>") — first-choice provider.
• @fallback("<provider>") — ordered fallback chain (repeatable).
• @maxLatencyMs / @maxTimeToFirstTokenMs — latency envelopes.
• @preferredRole("<role>") — agent roles the policy targets (repeatable).

Full source for one policy:

@primary("streamClaudeSonnet")
@fallback("stream54Pro")
@fallback("streamGeminiPro")
@maxLatencyMs(60000)
@preferredRole("assistant")
@preferredRole("specialist")
@description("Default chat policy for non-operator agents...")
policy balancedChat { }

File: dsl/policies/policies.memql.

#Builtins (66 total, 7 namespaces)

Builtins wrap Go integrations behind a declarative schema so they look like regular DSL function calls. Each declares an @executor (the Go integration or engine intrinsic it dispatches to); the body is the builtin's input schema.

A representative builtin:

@executor("integration.similarity.similarTo")
@args(profile="object", additionalProperties="true")
@description("Retrieve top-K nodes of the given concept ranked by cosine similarity...")
builtin similarTo {
  text      string  @required
  concept   string  @required
  limit     int
  provider  string
}

File: dsl/common/builtins.memql.

Two kinds of @executor value appear: integration executors (integration.<area>.<op> — dispatch to a registered Go integration plug-in) and engine-intrinsic executors (bare names like concepts, help, validate, error — handled directly by the engine).

#agents — dsl/agents/builtins.memql

#cognition — dsl/cognition/builtins.memql

#common — dsl/common/builtins.memql

#identity — dsl/identity/builtins.memql

#workbench — dsl/workbench/builtins.memql

#worker — dsl/worker/builtins.memql

#harness — dsl/harness/queries.memql

These two builtins are declared in the harness namespace's queries.memql file (not a builtins.memql), alongside the harness query functions.

#Verification summary

All counts and names in this document were enumerated directly from the dsl/ tree of the public repo (grep "^concept ", grep "^tool ", grep "^provider ", grep "^builtin ", and the single dsl/policies/policies.memql file). Totals:

• 100 concepts across 22 namespaces.
• 24 tools across 5 namespaces.
• 57 providers (6 base + 51 model) in one file.
• 5 SI Router routing policies in one file.
• 66 builtins across 7 namespaces (45 in common, 4 each in agents / cognition / identity, 5 in worker, 2 in workbench, and 2 in harness's queries.memql).

When this snapshot ages, re-run those greps against the source tree to refresh the tables.