CodeAtlas AI

The Living Engineering Ontology and Knowledge Graph Platform

Comment

Inspiration

Modern engineering organizations suffer from massive tribal knowledge fragmentation. When a new feature requirement arrives or a critical outage occurs, critical information is scattered across GitHub repositories, Jira tickets, Slack channels, Confluence runbooks, and Freshservice incidents.

Engineers waste hours trying to answer fundamental architectural questions:

  • Which repositories, APIs, and microservices will break if we modify this component?
  • Who is the real subject matter expert or owner for this legacy service?
  • Have we resolved a similar incident or architecture pattern before?

Traditional search and RAG tools simply retrieve raw documents without understanding underlying system topology. We built CodeAtlas AI to bridge this gap: shifting from naive text search to a Living Engineering Ontology & Knowledge Graph that can deeply reason about software architecture, ownership, blast radiuses, and dependencies.

What it does

CodeAtlas AI transforms fragmented company data into an interactive, multi-agent organizational brain:

  1. Living Engineering Ontology: Organizes raw engineering assets into structured entities—BusinessCapability, Service, Repository, API, Team, Engineer, Requirement, Incident, Document, and Runbook.
  2. Interactive React Flow Knowledge Graph: A visual canvas that traces complex service dependencies, data flows, and dynamically highlights downstream blast radiuses during architectural changes or outages.
  3. Multi-Agent Cooperative Pipeline: Coordinates 7 specialized, reusable agents for real-world engineering workflows:
    • Requirement Impact Agent: Calculates repository, API, and service blast radiuses for incoming product requirements.
    • Ontology Mentor: Explains domain capabilities, service lifecycles, and architectural patterns.
    • Expert Discovery Agent: Profiles service owners, code contributors, and point-of-contacts.
    • Incident Diagnosis Agent: Traces active incidents (e.g., timeouts, cache evictions) to upstream root causes and relevant runbooks.
    • Knowledge Gap Agent: Automatically audits microservices for missing runbooks, orphaned ownerships, or unmapped dependencies.
    • Architecture Storyteller: Narrates end-to-end service interactions and data flows.
    • Blast Radius Simulator: Evaluates the business impact of service downtime.
  4. Explainability & Verification: Provides transparent execution traces and agent handoffs with direct citations back to repository files, runbooks, and API endpoints.

How we built it

  • Frontend: Built with Next.js 15, TypeScript, and TailwindCSS, featuring an interactive React Flow graph canvas with dynamic node filtering, glowing dependency paths, and a dark-mode command center.
  • Backend & Multi-Agent Orchestration: Powered by FastAPI and Python 3.10+ using the OpenAI SDK to orchestrate asynchronous agent handoffs, context extraction, and prompt chaining.
  • Hybrid Data Layer:
    • Graph Layer: Neo4j for relationship traversals, dependency depth querying, and blast radius analysis.
    • Vector Layer: ChromaDB for semantic matching across requirements, documentation, and tickets.
    • Zero-Dependency Fallback Engine: Built-in in-memory Python graph structures and TF/cosine similarity fallbacks allowing instant zero-setup local trials without external databases.
  • Pluggable MCP Connectors: Designed mock Model Context Protocol (MCP) adapters to ingest context seamlessly from GitHub, Jira, Confluence, Slack, Freshservice, and Freshdesk.
  • Containerization: Docker and Docker Compose orchestration for unified multi-service deployments (including 1-click blueprint deployment to Render).

Challenges we ran into

  1. Multi-Agent Handoff Latency & Consistency: Ensuring that the output of the Impact Analysis agent smoothly piped relevant node IDs into the Ontology and Expert agents without hallucinating or losing topological context.
  2. Graph Visualization Performance: Rendering interconnected microservice graphs with over a hundred relationships while keeping the React Flow UI responsive with real-time blast-radius highlighting and smooth zoom/pan interactions.
  3. Zero-Configuration Fallback Architecture: Developing an in-memory graph and vector fallback mechanism in pure Python that mirrored Neo4j Cypher and ChromaDB vector queries so the application could run flawlessly on any developer machine without heavy infrastructure dependencies.

Accomplishments that we're proud of

  • Full-Loop Knowledge-to-Action: Successfully taking an unstructured product requirement (e.g., "Add WhatsApp notifications for order updates") and producing an explainable, step-by-step implementation plan with exact impacted microservices, APIs, test suites, and responsible team owners.
  • Real-time Blast Radius Simulation: Building an intuitive visual graph experience where clicking a single service visually dims unrelated nodes and illuminates the ripple effect of dependencies across the entire organization.
  • Resilient Dual-Mode Data Layer: Creating a unified backend interface that transitions seamlessly between enterprise Neo4j/ChromaDB instances and ultra-fast in-memory mock datasets.

What we learned

  • Graphs Beat Pure RAG for Architecture: When dealing with distributed systems, vector search alone falls short. Pairing semantic vector search with structural graph traversals produces vastly superior, hallucination-resistant engineering insights.
  • Modular Agent Specialization: Breaking down complex architectural reasoning into single-responsibility agents (Impact, Expert Discovery, Incident Diagnosis) produces much more reliable and explainable results than a single monolithic prompt.

What's next for CodeAtlas AI

  • Live CI/CD & IDE Integration: Build IDE extensions (VS Code / JetBrains) and GitHub Action bots to post blast-radius summaries and missing-owner warnings directly on pull requests.
  • Real-time Incident Correlation: Connect live Datadog / OpenTelemetry traces directly to the knowledge graph to automatically correlate active APM alerts with recent code deployments.
  • Automated Architecture Drift Detection: Continuously parse repository ASTs, OpenAPI specs, and Terraform manifests to keep the Living Ontology synchronized with production without manual documentation updates.

Built With

Share this project:

Updates