SynapseLantern

World-Class RAG for Distributed Codebases

Unify, understand, and query your entire microservice architecture—across every repo, every service, every call chain.

Request a Demo

The Multi-Repository Problem

Traditional Tools (Jules, etc.)

user-service repo
Analyzed in isolation
payment-service repo
Analyzed in isolation
notification-service repo
Analyzed in isolation
❌ No Cross-Repository Understanding

Our RAG System

user-service repo
Analyzed in context
payment-service repo
Analyzed in context
notification-service repo
Analyzed in context
✅ Unified Cross-Repository Graph

Repository-Level Limitations

  • •Single-repo scope: Tools like Jules can only see one repository at a time
  • •Broken API chains: Can't trace calls from user-service → payment-service → notification-service
  • •Missing context: "How does checkout work?" only shows payment logic, not the full flow
  • •Deployment blindness: No understanding of how services interact in production

Real-World Impact

  • •Debugging nightmares: "Why is checkout failing?" requires manually checking 5+ repos
  • •Onboarding confusion: New devs can't understand how the system actually works
  • •Architecture drift: No visibility into actual service dependencies vs. intended design
  • •Change impact analysis: Can't predict what breaks when modifying an API

Example: "How does user registration work?"

Traditional Tools Response:
"I found a POST /register endpoint in the user-service that validates email and creates a user record."
❌Missing: email verification service, welcome email flow, analytics tracking
Our RAG System Response:
"Registration involves 4 services: user-service creates the account, email-service sends verification, analytics-service tracks the event, and notification-service sends welcome messages. Here's the complete flow..."
✅Complete cross-repository understanding

Visualize & Truly Understand Your Codebase

Still dumping code into large context windows?
Here’s what you’re missing.
Microservice call graph visualization
Large codebase visualization
Legend: Node colors represent Microservices, Folders, Code, Files, and Other.
See the structure. See the relationships. See the truth.

Competitive Analysis

Capability Traditional Tools Our RAG System
Repository Scope Single Repo Only Multi-Repo Unified
Cross-Service API Tracing Impossible Full Call Chains
Search Methodology Keyword Only Hybrid Multi-Modal
User Personalization Generic Responses Role-Based Adaptation
Architectural Understanding Fragmented Holistic System View
Impact Analysis Single Service Cross-Service Effects

Three Core Architectural Advantages

🕸️

Graph-Based Microservice Mapping

Unlike traditional tools that analyze services in isolation, our system builds a comprehensive relationship graph using Neo4j to understand cross-service dependencies, API call chains, and data flow patterns.

MATCH (service:Service)-[:CALLS]->(api:API)
WHERE service.name = "user-service"
RETURN api.endpoint, api.method
🔍

Hybrid Search Architecture

Combines semantic vector search (pgvector) with traditional keyword search and graph-scoped retrieval. This multi-modal approach ensures both conceptual understanding and exact matches within proper architectural context.

Semantic: "authentication flow"
Keyword: "JWT.verify()"
Graph-Scoped: Within auth-service
👥

Adaptive Response Generation

Leverages user context and role-based prompting to generate responses tailored to technical expertise level. The same query generates different explanations for developers, product managers, and executives.

Developer: "The JWT middleware validates tokens using RS256..."
PM: "Users stay logged in through secure session tokens..."

System Architecture Overview

Storage Pipeline

1. Parse Pipeline

TypeScript/JavaScript AST parsing with strategy pattern for extensibility

2. Graph Synchronization

Neo4j relationship mapping with differential updates

3. Vector Embedding

PostgreSQL + pgvector for semantic search capabilities

Query Pipeline

1. Intent Classification

LLM-powered query understanding and strategy selection

2. Multi-Modal Retrieval

Parallel execution of semantic, keyword, and graph-scoped search

3. Context-Aware Generation

Role-based response formatting with architectural context

Technical Implementation Details

Data Storage Layer

  • Neo4j: Service relationships, API call graphs, dependency mapping
  • PostgreSQL: Code metadata, chunks, API endpoints, unresolved calls
  • pgvector: Semantic embeddings for conceptual search
  • Git Integration: Differential updates based on commit changes

Query Processing

  • Intent Classification: LLM-powered query understanding
  • Strategy Selection: Dynamic choice of retrieval methods
  • Parallel Retrieval: Concurrent semantic, keyword, and graph queries
  • Context Fusion: Intelligent merging of multi-source results
System Architecture Diagrams
📊
Storage Architecture
Detailed storage pipeline and data flow
🔍
Retrieval Architecture
Query processing and retrieval flow

Contact Me

Interested in learning more about this advanced RAG system for distributed codebases?

📧 maximorobbio@gmail.com
× Zoomed visualization