Graphify’s whole claim to being more than RAG with extra steps rests on one specific technique — tree-sitter AST parsing — that’s worth actually explaining rather than taking on faith.
AST stands for Abstract Syntax Tree. It’s a structured representation of code’s actual grammar: not the raw text of a source file, but a tree showing what each piece of code is and how the pieces relate — this is a function definition, it contains this parameter list, this call expression references that function defined elsewhere, this variable is assigned inside this specific block. A compiler builds one of these for every piece of code it processes, because it needs to understand the actual structure to do anything with it — check types, catch errors, generate machine instructions. Tree-sitter is a widely used library for building these trees quickly and incrementally, which is exactly what a tool like Graphify uses under the hood.
Why this is a fundamentally different kind of understanding than an embedding. An embedding-based system reads a chunk of code, converts it into a vector, and later finds relevant code by measuring how close two vectors sit in that mathematical space — a real, useful technique, but fundamentally a similarity approximation. It can tell you “this chunk resembles that chunk,” which is often good enough, but it doesn’t actually know that this function calls that one; it just noticed the text looks related. An AST doesn’t approximate that relationship — it knows it directly, because the relationship is explicit in the code’s actual grammar, and the tree was built by parsing that grammar correctly, not by guessing from surface similarity.
Why that distinction matters practically, not just philosophically: it’s the entire basis for Graphify’s EXTRACTED versus INFERRED tagging. A connection pulled directly from the AST — this function calls that one — is EXTRACTED: verifiably true, because it’s read straight out of the code’s actual structure. Anything requiring a further reasoning step to resolve gets marked INFERRED instead. An embedding-based system has no equivalent distinction to offer, because everything it finds is already an approximation — there’s no version of “read directly from the source” available to it, since similarity was always the mechanism, not a verification step layered on top of one.
The honest tradeoff, since AST parsing isn’t strictly better in every way: it requires a real, structured grammar to parse against, which code has and looser natural-language text mostly doesn’t — you can’t build a meaningful syntax tree out of a support ticket or a Slack thread the way you can out of a function body. That’s precisely why Graphify still falls back to a semantic, model-driven pass for docs, PDFs, and other unstructured content, rather than trying to force everything through AST parsing. Deterministic structure is the right tool specifically where real structure already exists; approximation is still the right tool everywhere else.
