FalkorDB
Solutions
Use cases
Why FalkorDB
Developers
Auryn · open-source code graph

Code Graph to Power Your Organization’s Agents

Auryn gives your coding agents a holistic view of every repository your teams own. All code is mapped into a single graph, so any symbol, dependency, or call path is within reach. Agents work with greater accuracy, complete tasks faster, and consume fewer tokens.

MIT license Runs on your machine Works with the agent you use
Agent who calls OrderController.Submit?
who_calls("OrderController.Submit") 3 hops · 2 repos · cited

SubmitOrderButton (web-portal) and NightlyReorderJob (api-gateway) call it.

Token consumption −24%

466k to 355k tokens per task.

Agent run time −66%

208s to 70s per task.

Accuracy 4x

92% of key facts covered, vs 22% without Auryn.

Agent spend −47%

$0.72 to $0.38 per task.

without Auryn with Auryn

How it works

~/meridian — terminal
$ pip install falkordb-auryn Successfully installed falkordb-auryn $ auryn install ✓ Claude Code registered ✓ Cursor registered ✓ Copilot registered Graph store: embedded FalkorDB, on this machine Files written to your repositories: 0 Restart your agent and ask your first question.
> new here — how does a checkout flow through this system? Auryn index_repository ×4
web-portal TS
64 nodes
api-gateway C#
48 nodes
platform-core Python
71 nodes
platform-db SQL
42 nodes
⎿ "meridian": 225 nodes · TS · C# · Python · SQL git commit -m "promo lookup" ↻ commit hook: 2 files re-parsed, graph updated
> what breaks if I change PKG_ORDERS.SUBMIT? Auryn impact_of("PKG_ORDERS.SUBMIT") ⎿ OrderController.Submit api-gateway · C# ⎿ SubmitOrderButton web-portal · TS ⎿ NightlyReorderJob api-gateway · C# Auryn find_path(SubmitOrderButton, ORDER_LINES) ⎿ 4 hops · each cited with its file and edge ● Two callers and one screen reach this procedure, across 3 languages.

One graph across all your repositories.

Most organizations split their code across many repositories and many teams. Auryn maps all of it as a single graph. When a repository references code that is not yet indexed, Auryn records it and links it as soon as the repository is added.

Features

01

Incremental resync

On each commit or branch switch, Auryn re-parses only the modified files and the code they affect, approximately 150x faster than a full re-ingestion.

commit 4f2a91c · feature/promo
web-portal/CheckoutButton.tsx re-parsed
api-gateway/OrdersController.cs re-parsed
platform-core/billing/promo.py re-parsed
platform-core/billing/charge.py re-parsed
platform-core/ledger/record.py re-parsed
platform-db/pkg_orders.sql re-parsed
2 of 1,184 files ≈150x faster
02

Semantic search, built in

Full semantic search is built in and available out of the box. No separate search service is required.

03

Works with the agents your teams use

Supports Claude Code, Cursor, Copilot, and other widely used coding agents immediately after installation.

04

Many repos, one graph

Repositories may be added in any order, from any team. When code references a symbol that is not yet indexed, Auryn records the reference and resolves it once that repository is added.

05

Deep code semantics

Auryn performs two levels of analysis. A fast static pass runs first and is sufficient for many codebases. A deeper analysis then runs in the background for languages such as Python and C#, ensuring that critical information in weakly typed languages is captured.

06

Cited answers

See what your agent did. It reasons with the graph, and each answer references the node, file, and edge from which it was derived.

answer · 3 citations

The promo code reaches billing.charge through apply_promo.

[1] ApplyPromo web-portal/promo.tsx · CALLS_API
[2] promo_endpoint platform-core/api.py · CALLS
[3] apply_promo → billing.charge billing/promo.py · CALLS

Auryn vs Graphify

Measured head to head on the same repos, the same commits, and the same machine.

Faster queries 100x+
Auryn
Graphify
Faster ingest Up to 3.8x
Auryn
Graphify
Faster resync Up to 7x
Auryn
Graphify
Feature Auryn Graphify
Search & filtering Hybrid vector, lexical, and full-text search, run over the graph. Lexical BFS only.
Incremental resync Re-parses only a commit’s blast radius. Full re-ingestion.
Deep code semantics Static pass plus background deep-analysis enrichment. Static only.
Cross-repo resolution Placeholders upgraded in place. Graph merge.
Storage model FalkorDB graph database. JSON file on disk.

Closure. Blast radius. Traceability.

Built in. Before an agent changes shared code, it checks who calls it, what the change reaches, and how they connect.

Callers
Changed symbol
Procedure
Table
Three languages · one query

The same graph for your engineers and your agents.

Your engineers can open the graph your agents query and see exactly what they relied on.

Open source. MIT license.

Read the code, run it on your own infrastructure, and build on it. Issues and pull requests are welcome.

View on GitHub
License

MIT

A permissive license. Use it, change it, and ship it in your own products.

Built on

FalkorDB

The graph lives in FalkorDB, a property graph database, not a JSON file.

Your code

Stays with you

Parsing runs locally. The graph lives on your machine or a FalkorDB server you run.

Your repos

Untouched

Install is user-scoped. Nothing is written into your repositories.

Auryn FAQ

How it works
How is this different from semantic or vector search?

Auryn includes semantic search. The difference is what comes back: the matching code plus its calls, imports, and dependencies, so the agent can act on it without reading around.

Our editors already have "go to definition." Why a graph?

Go to definition answers one hop. A graph answers what spans the codebase: the blast radius of a change, every path between two symbols, and everything an endpoint touches down to the tables. Your agent can query it too, not just you.

Does semantic search replace the graph?

No. Search finds the code. The graph shows what that code calls, imports, and depends on, including across repos.

What are closure, blast radius, and traceability?

Closure is everything a change can reach. Blast radius is who calls it and what the change can break. Traceability is the path between them, each hop cited with the file and the edge.

Agents
What changes for our agents?

They can take on work that spans repositories and languages without reading the tree first. On the same graded questions, answers covered 92% of key facts instead of 22%, agent run time dropped 66%, and cost per task dropped 47%.

Which agents does it work with?

Claude Code, Cursor, Copilot, Codex, Gemini, Windsurf, VS Code, and Aider, plus any agent that reads AGENTS.md.

Repositories and teams
Can one graph cover more than one repo?

Yes, and it’s the main use case. Add repos in any order and cross-repo references connect as each one arrives. Microservices, a monolith split across repos, and shared libraries all work.

How fast is a resync after we change code?

Seconds. Auryn re-parses only the files a commit touched and the code they affect. Angular, at 5,256 TypeScript files, moves to the next release in under 8 seconds.

Can our teams share one graph?

Yes. Point Auryn at a shared FalkorDB server and every team’s agents query the same graph.

Privacy and storage
Does it write into our repositories?

No. Install is user-scoped and the graph lives outside your repos.

Where does our code go?

Parsing runs locally. The graph lives on your machine or on a FalkorDB server you run.

How is the graph stored?

In FalkorDB, a graph database, not a JSON file. It stays loaded, so caller and impact lookups come back in about 5 ms on repos the size of Django and Angular.

Start with one repo. Roll it out to every team.

One command installs Auryn and plugs it into the agents your teams already use. Add repos as you go. Your agents give more accurate answers, burn fewer tokens, and finish in a third of the time, at about half the cost.