DevGraph AI

Overview

DevGraph AI is my AI-Powered Developer Assistant project. It indexes a local TypeScript repository, retrieves relevant code and asks Gemini to answer using that context. The interface shows the answer alongside its source files and line ranges. What I built: the scanner, chunker, embedding and Qdrant pipeline, answer service and Next.js interface. I connected the backend and frontend and made source locations visible. It remains a prototype; answer quality has not been benchmarked.

Architecture in practice

FastAPI separates scanning, embeddings, Qdrant storage and answering into services. Next.js exposes indexing and question workflows. Retrieved sources retain a file path, line range and chunk index.

Local TypeScript: scan .ts and .tsx, skipping dependencies and build output. Remote ingestion is not implemented.
Source locations: let readers find the code behind an answer.
Prompt boundaries: request answers from retrieved context and acknowledge missing evidence. Correctness still needs evaluation.

INTERACTIVE ENGINEERING EXAMPLE

Before retrieval: preserve the source.

Change the chunk size and overlap to inspect how source lines become context. Smaller chunks offer less context; overlap repeats boundary lines. This simple approach can split a function in the middle.

Synthetic code · deterministic chunking · no embeddings, semantic search or LLM output

Lines per chunkOverlapping lines

3 chunks · viewing lines 1–10synthetic/inventory.ts · source metadata travels with the content

 1  // Synthetic example: inventory.ts
 2  type Item = { id: string; stock: number; price: number };
 3  
 4  export function available(items: Item[]): Item[] {
 5    return items.filter(item => item.stock > 0);
 6  }
 7  
 8  export function subtotal(items: Item[]): number {
 9    return items.reduce((sum, item) => sum + item.price, 0);
10  }

Inspect the full synthetic input

 1  // Synthetic example: inventory.ts
 2  type Item = { id: string; stock: number; price: number };
 3  
 4  export function available(items: Item[]): Item[] {
 5    return items.filter(item => item.stock > 0);
 6  }
 7  
 8  export function subtotal(items: Item[]): number {
 9    return items.reduce((sum, item) => sum + item.price, 0);
10  }
11  
12  export function findItem(items: Item[], id: string) {
13    return items.find(item => item.id === id);
14  }
15  
16  export function describe(item: Item): string {
17    return `${item.id}: ${item.stock} available`;
18  }
19  
20  // Chunk boundaries follow lines, not syntax trees.

This educational port follows the public project's line-based algorithm. Its outputs are checked against fixtures executed with the original Python function. It demonstrates chunking behavior, not retrieval quality or a live DevGraph service.Inspect the original chunker

Engineering details, validation and next steps

A real boundary: context versus structure

The chunker splits by line count with overlap, rather than syntax trees. Overlap keeps nearby source lines in adjacent chunks, but a function can still be split midway. The lab above makes that tradeoff visible without implying measured retrieval quality.Embedding and answer services use Gemini in the reviewed source. Qdrant stores vectors together with source metadata. The code contains compatibility paths for Qdrant query APIs and model discovery, but those paths have not been independently validated against live services in this portfolio review.

Testing and reliability

For this portfolio lab, the original public Python chunking function was executed on 20 synthetic input/configuration combinations. The browser-side implementation was compared against those outputs, including empty input, overlapping chunks and final short chunks. Additional checks reject invalid parameters and verify that every input line remains represented.These are deterministic chunking checks, not end-to-end RAG tests. No paid inference, retrieval benchmark, answer-accuracy evaluation or production load test was performed.

Current state and limitations

A learning prototype with a public implementation. Running the complete service requires Qdrant and configured Gemini access. Authentication, prompt-injection defenses, stable cross-process vector identifiers and broader evaluation need further work. The reviewed source does not establish an OpenAI integration, despite the broader stack label in my PDF resume.

Future improvements

Evaluate retrieval on a small question/source set, stabilize vector identifiers, add permission boundaries and compare line-based chunks with syntax-aware chunks. These are next steps, not completed features.

Inspect the source

Repository · Scanner · Chunker · Indexing · Answer service · Frontend