every format, one output
anrlc isn't a json-to-anrl converter. it's a universal compiler for any context you want to inject into an llm — structured data, documentation, source code, configuration, or raw text.
16+ formats, four ingestion tiers
each tier uses a purpose-built ingestion strategy. tier 0 walks custom language asts. tier 1 uses a generic tree-sitter cst. specialized formats get domain-aware parsers.
json/yaml objects become entity graphs. arrays are tabular-flattened when homogeneous. null/empty values are pruned. markdown headings become anchors. plain text generates prose entity blocks.
purpose-built walkers extract modules, imports, function declarations, type definitions, and class hierarchies as typed entities and edges. import statements become --imports--> edges for cross-file linking.
tree-sitter concrete syntax tree walk extracts module/use/import declarations and top-level identifiers. sufficient for project linking; not full ast-depth analysis.
domain-specific walkers for functional and logic programming patterns, relational schemas, assembly instruction streams, and ir-level analysis.
json: object graphs and tabular data
three density-driven compiler optimizations transform json payloads: null/empty pruning, inline scalar namespacing, and tabular column flattening. wide-array and null-heavy json achieves net-positive token compression.
{
"name": "payment-gateway",
"status": null,
"empty_logs": [],
"db": {
"host": "10.0.0.1",
"port": 5432
},
"replicas": 3
}!1.0 @Payment_Gateway :: Service *name: payment-gateway # null pruned ← +53% savings on null-heavy payloads # [] pruned !0.8 @DB :: Object *db.host: 10.0.0.1 ← scalar namespace flattening *db.port: 5432 *replicas: 3
tabular flattening: arrays of homogeneous objects (≥3 rows, ≥60% cell density) are rotated from row-oriented to column-oriented: *items.id: 1 | 2 | 3. this reduced large_flat.json from −89% to +21% net compression.
yaml: configuration and helm charts
yaml shares the json ingestion path after parsing. configuration files with deep nesting produce entity hierarchies with --contains--> edges. the compiler distinguishes configuration scalars from operational values using depth-based weight quantization.
replicaCount: 3
image:
repository: gcr.io/myapp
tag: "2.4.1"
resources:
limits:
cpu: "500m"
memory: "512Mi"
service:
type: ClusterIP
port: 8080!1.0 @Root :: Config *replicaCount: 3 !0.8 @Image :: Object *image.repository: gcr.io/myapp *image.tag: 2.4.1 !0.8 @Resources_Limits :: Object *resources.limits.cpu: 500m *resources.limits.memory: 512Mi !0.5 @Service :: Object *service.type: ClusterIP *service.port: 8080
markdown: documentation and prose
the markdown ingester uses a pulldown-cmark event loop. headings become anchor entities. code blocks become primitive nodes. prose paragraphs become text primitives attached to the nearest heading entity. tables trigger tabular flattening. the semantic pass is most likely to trigger on markdown prose (high prose entropy, low structural link density).
# System Status Report ## Database The primary DB is healthy. Backup sync is delayed. ## API Layer Response time is 240ms avg. Error rate: 0.3%
!1.0 @System_Status_Report :: Document !0.8 @Database :: Section *text: The primary DB is healthy. *text: Backup sync is delayed. !0.8 @API_Layer :: Section *text: Response time is 240ms avg. *text: Error rate: 0.3% !0.8 @System_Status_Report --contains--> @Database !0.8 @System_Status_Report --contains--> @API_Layer
source code: modules, imports, and types
tier 0 walkers use tree-sitter to parse exact syntax trees. function declarations, class definitions, type aliases, and module imports become typed entities and edges. import statements become --imports--> edges that the project linker resolves to in-project entities or external stubs — enabling cross-file knowledge graphs from an entire codebase.
from database import connection
from auth import verify_token
class PaymentAPI:
def process(self, amount: float) -> bool:
if not verify_token(self.token):
return False
return connection.execute(amount)
def refund(self, tx_id: str) -> dict:
return connection.fetch(tx_id)# module: src/api.py !1.0 @api_py :: Module *import: database *import: auth !0.8 @PaymentAPI :: Class !0.5 @process :: Method *return: bool !0.5 @refund :: Method *return: dict !0.8 @api_py --imports--> @database ?0.9 !0.8 @api_py --imports--> @auth ?0.9
class hierarchies, decorators, type annotations, __init__.py-aware module paths
trait impls, struct fields, fn signatures, Cargo.toml-aware module paths, use statements
package declarations, struct types, interface definitions, import paths
interface/type aliases, class members, generics, re-exports
generic cst: top-level declarations, require/import statements
generic cst: function prototypes, include directives, struct declarations
write anrl directly
for cases where you want full control — rag pipelines, agent memory systems, or hand-crafted context windows — you can write anrl directly and compile it through the optimizer and formatter for weight quantization, confidence calibration, and anchor duplication.
# hand-crafted anrl — direct system context injection !1.0 ^query: Which service is causing the outage? !1.0 ^traverse: dependency graph from @Incident_Node !1.0 ^return: root cause entity with highest !weight !1.0 @Incident_Node :: Alert *severity: critical *time: 2026-05-30T14:22:00Z !0.8 @API_Gateway :: Service !0.8 @Database_Primary :: Postgres *status: degraded ?0.9 !1.0 @API_Gateway --depends_on--> @Database_Primary !1.0 @Database_Primary => @API_Gateway_Degraded