The Enterprise Knowledge Graph
Engineered for Zero Operational Drag

# Pure NumPy Contiguous CSR Slicing Algorithm
import numpy as np

def traverse_blast_radius(start_idx: int, max_depth: int, fwd_all, fwd_lineage):
    visited = {start_idx}
    queue = [(start_idx, 0)]
    impacted_nodes = []
    
    while queue:
        curr_idx, depth = queue.pop(0)
        if depth >= max_depth:
            continue
            
        # Select dual CSR index: fwd_all for depth 1, fwd_lineage for depth >= 2
        indptr, targets = (fwd_all if depth == 0 else fwd_lineage)
        
        # Zero-overhead contiguous slice: targets[indptr[curr_idx]:indptr[curr_idx + 1]]
        start_pos = indptr[curr_idx]
        end_pos = indptr[curr_idx + 1]
        neighbors = targets[start_pos:end_pos]
        
        for neighbor in neighbors:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append((neighbor, depth + 1))
                impacted_nodes.append(neighbor)
                
    return impacted_nodes # Executed in ~0.02 ms (20 microseconds)

# In-process quantized embedding generation & L2 unit normalization
from core.embedder import LocalEmbedder
from core.models import Node, NodeType

# 1. Initialize quantized INT8 ONNX embedder (zero external API latency)
embedder = LocalEmbedder()

# 2. Node with domain properties
node = Node(
    id="analytics.mart_orders",
    type=NodeType.DATASET,
    name="mart_orders",
    description="Consolidated customer orders mart for revenue analysis"
)

# 3. Generate domain-specific representation and normalized 384-dim vector
semantic_text = embedder.format_node_text(node)
embedding_vector = embedder.embed_text(semantic_text)

# Norm verification: np.linalg.norm(embedding_vector) == 1.0
print(f"Generated {len(embedding_vector)}-dim normalized vector: {embedding_vector[:4]}...")

# GraphRAG Context Synthesis: Combining Vector Search + CSR Blast Radius
from control_plane.src.query_engine import QueryEngine
from control_plane.src.prompt_synthesizer import PromptSynthesizer

# 1. Initialize Unified Query Engine over Delta Lake
engine = QueryEngine(data_path="/data/tenants/default/")

# 2. Hybrid Step A: Semantic Vector Discovery via BLAS Dot-Product
candidates = engine.vector_store.search_similar(query="customer churn revenue", top_k=1)
target_node_id = candidates[0]["id"]  # "analytics.marts.fct_churn"

# 3. Hybrid Step B: Microsecond CSR Multi-Hop Traversal (5 Hops)
traversal_result = engine.graph_store.traverse_blast_radius(
    node_id=target_node_id, 
    max_depth=5
)

# 4. GraphRAG Context Synthesis: Format structured prompt for AI Agent
synthesizer = PromptSynthesizer()
llm_prompt = synthesizer.build_blast_radius_prompt(traversal_result)

# Send to OpenAI, Gemini, or local Ollama instance (http://localhost:11434)

from openai import OpenAI
from control_plane.src.agent_tools import (
    get_dataset_blast_radius,
    get_lineage_time_travel_diff
)

# 1. Retrieve Graph Context & Synthesized GraphRAG Prompt
blast_radius_prompt = get_dataset_blast_radius(
    node_id="postgres.raw.raw_customers",
    max_depth=5
)

# 2. Dispatch Context to LLM of your choice (OpenAI, Gemini, or local Ollama)
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are LineagIQ AI Agent, an expert enterprise data architect."},
        {"role": "user", "content": blast_radius_prompt}
    ]
)

print(response.choices[0].message.content)