Code Intelligence Through Structure: A Vectorless RAG-Inspired Approach for Python, R, and SQL Codebases

Using a codebase's own structure — files, functions, dependencies, SQL etc.— as a precise retrieval layer for AI-assisted code understanding.

Codebases already contain a remarkable amount of structure. Files import each other. Functions call functions. Scripts embed SQL that touches specific tables. Configurations flow into business logic. These relationships are precise, deterministic, and rich with meaning.

Inspired by the idea of Vectorless RAG, I have been working on a project with the goal of making codebases easy to understand, review, document, and validate.

This article walks through what the system does, the kinds of questions it answers well, and where it's been most useful in practice.

Core Idea: Code has an inherent deterministic structure. The system treats it that way.

Functionality Overview:

At a high level, the system parses code written in Python, R, & SQL to extract and organize details such as:

• files, folders, scripts, functions, classes, and variables
• imports, dependencies, and function calls
• embedded SQL and database/table usage
• configuration usage
• relationships across code components
• data lineage and execution flow
• visual representations of the codebase

 The system follows a bottom-up approach to build summaries of functions, classes, files, projects, etc. These details are embedded in a structured layer built in JSON format. The structured layer can be reviewed deterministically or act as a grounded context for LLM evaluation.

This structured code intelligence layer can then help answer practical questions such as:

• Where is a specific logic implemented?
• What does this function depend on?
• Which SQL queries or tables are being used?
• How does data flow through the codebase?
• What parts of the code may require closer review?
• Which components may be impacted if a function changes?

These questions come up constantly during onboarding, code review, model validation, and impact analysis. A structural map makes each one a traversal rather than a search.

The system has a flexible AI layer. It can work with foundational LLMs like OpenAI and Anthropic models through APIs as well as locally hosted models through Ollama, depending on privacy requirements, deployment constraints, and organizational policies.

The approach is inspired by Vectorless RAG, where retrieval does not have to rely entirely on embeddings or vector databases. Instead, the system can use structured metadata, relationships, lineage, and deterministic traversal to locate relevant information. This is especially useful in cases where access to vector databases is limited, or where teams have access to foundational models but not the full RAG infrastructure stack.

Some of the key advantages of this approach include:

• Works even when vector databases are not available. The system can rely on structured relationships, metadata, and deterministic traversal rather than relying solely on vector search.
• Useful for organizations with limited AI infrastructure, teams that have access to foundational models, but not the entire RAG technology stack, can still benefit from AI-assisted codebase understanding.
• Supports local model deployment. With Ollama integration, analysis can be performed using locally hosted models, which may be helpful for teams with data privacy, security, or network restrictions.
• Improves onboarding for new team members. New joiners can quickly understand the structure of a codebase, key files, major functions, data flows, dependencies, and execution paths.
• Reduces dependency on tribal knowledge. Important implementation details often live in the minds of a few developers. This approach helps convert that knowledge into structured, reviewable documentation.
• Supports impact analysis. Before changing a function, users can identify upstream and downstream dependencies, related SQL, configuration values, and affected outputs.
• Improves documentation quality. Instead of relying only on manually maintained documentation, the tool can generate documentation grounded in the actual codebase.
• Makes code relationships easier to visualize. Visual maps of components, execution flows, and data lineage can make complex systems easier to explain to both technical and non-technical stakeholders.
• Creates a foundation for guideline-to-code traceability. Once the codebase is represented structurally, it becomes easier to compare implementation against design documents, model specifications, coding standards, or validation guidelines.

Limitations

A few areas where the approach is still maturing:

• The system tends to work better on codebases with a reasonably clean structure. Highly dynamic Python (heavy metaprogramming, runtime-generated SQL) is harder to parse.
• Coverage of R is more limited than Python—something to be expanded on in future iterations.

The broader goal is to help teams reduce the time required for codebase understanding, onboarding, documentation, review, impact analysis, and validation.

Is this project a silver bullet? No 😊, but it does offer clear advantages in helping users become familiar with a new codebase and providing a practical guide for onboarding.

If you've worked on something similar, or if your team is exploring how to bring AI-assisted understanding to your codebase, I'd genuinely like to hear how you've approached it. And if you're curious about the tool itself, feel free to reach out.

Tested on Python and SQL codebases using Ollama with Qwen2.5-Coder.

Coding Assistance Used: Codex & Claude

Repo Link: https://github.com/SudhanshuChib/Vectorless-CodeIntel