Bridging Semantic Gaps with BigQuery AI: Introducing KonveyN2AI

Author(s): Neeharika Vemulapati

Originally published on Towards AI.

Have you ever been stuck trying to understand a system where the documentation is incomplete, inconsistent, or missing altogether?
Whether it’s legacy COBOL code, Kubernetes manifests, MUMPS procedures, or IRS data layouts, knowledge gaps can grind productivity to a halt.

What if we could detect these gaps automatically — surfacing missing links, semantic mismatches, and undocumented rules in real time?

That’s the idea behind KonveyN2AI, a project we recently built for the BigQuery AI Hackathon. Powered by BigQuery’s new vector capabilities, it’s a multi-agent architecture that spots knowledge gaps across diverse artifact types — without relying on an external vector database.

🔎 The Problem: Hidden Knowledge Gaps

Modern systems often span:

• Cloud-native configs like Kubernetes YAML
• Legacy codebases like COBOL and MUMPS
• APIs and schemas like FastAPI
• Regulatory layouts like IRS files

Each comes with implicit knowledge. Teams waste hours deciphering these “gaps,” leading to bugs, delays, and frustration. Existing solutions (LLMs + vector DBs) help, but they’re costly, complex, and often slow.

💡 The Idea: KonveyN2AI

KonveyN2AI is designed to:

1. Ingest heterogeneous artifacts (code, configs, layouts)
2. Chunk and embed them using Google’s text-embedding-004
3. Store embeddings directly in BigQuery (using VECTOR columns)
4. Search, score, and rank gaps with BigQuery’s native vector functions (VECTOR_SEARCH)
5. Surface results via agents orchestrated in a governance-inspired model

Inspired by Chanakya’s Saptanga framework of governance, KonveyN2AI’s agents are:

• Svami (the orchestrator) — routes queries
• Janapada (the memory) — stores embeddings & metadata
• Amatya (the prompter) — crafts AI queries & responses

⚙️ How It Works

1. Ingestion & Embedding

Artifacts are parsed, deduplicated, chunked, and hashed for idempotency. Each chunk is embedded (768-dim vector), reduced via PCA (3072 → 768 dims), and cached for efficiency.

2. Vector Search in BigQuery

Instead of paying for and maintaining a separate vector DB, embeddings live inside BigQuery:

SELECT *
FROM konveyn2ai.artifacts
WHERE VECTOR_DISTANCE(embedding, @query_vec) < 0.25
ORDER BY VECTOR_SEARCH(embedding, @query_vec)
LIMIT 10;

If BigQuery is temporarily unavailable, KonveyN2AI falls back to an in-memory index.

3. Hybrid Scoring

Deterministic SQL filters combine with AI confidence scores. This hybrid model reduces hallucinations while ranking gaps more reliably.

4. Results & Dashboard

Outputs include:

• Heatmaps of similarity scores
• Latency benchmarks (sub-second search)
• Interactive dashboard showing artifact clusters and detected gaps

📈 [Knowledge Gap Visualization Dashboard]

🚀 Results

• 5+ artifact types tested (Kubernetes, COBOL, FastAPI, IRS layouts, MUMPS)
• Sub-second latency for typical queries
• Cost savings by eliminating external vector DBs
• Improved reproducibility via caching, error handling, and BigQuery-native storage

Extended Insights and Use Cases

While KonveyN2AI was born out of a hackathon experiment, its potential goes far beyond proof-of-concept. Let’s dive deeper into the challenges it addresses, and the practical impact it can have in enterprise environments.

1. Why Legacy + Modern Systems Clash

Organizations rarely get the luxury of starting fresh. Legacy systems (COBOL, MUMPS, JCL) often coexist with modern microservices (FastAPI, Node.js, Kubernetes). Each generation of technology brings its own:

• Terminology (e.g., COBOL “records” vs. SQL “tables”)
• Encoding assumptions (e.g., fixed-width vs. JSON/Avro)
• Hidden defaults (e.g., YAML null values vs. explicit schema fields)

KonveyN2AI can act as a semantic bridge — surfacing where assumptions misalign before they cause failures.

2. Case Study: Kubernetes + API Drift

Imagine a Kubernetes YAML defining a service on port 8080. The backend FastAPI service, however, listens on port 9090. Such mismatches typically emerge only at runtime, often in staging or production.

With KonveyN2AI:

• Both artifacts are chunked + embedded.
• The system detects similarity between “service port” and “backend listen port” fields.
• A semantic gap is flagged → YAML’s 8080 vs. API’s 9090.
• Dashboard shows the mismatch, with confidence score and metadata.

Result: faster detection, fewer deployment rollbacks.

3. Technical Deep Dive

• Storage in BigQuery → Unlike external vector DBs, embeddings sit inside BigQuery’s VECTOR type. This reduces operational overhead, avoids data silos, and leverages BigQuery’s scalability.
• Dimensionality Reduction → PCA compresses high-dimensional embeddings to reduce cost while retaining ~95% semantic variance.
• Hybrid Scoring → Rules-based filters (e.g., regex checks, schema alignments) work alongside LLM scoring to reduce false positives.
• Fallback Modes → If BigQuery is unreachable, an in-memory FAISS-like index maintains availability.

4. Future Directions

KonveyN2AI today is a strong proof-of-concept, but here’s where it could evolve:

• Artifact expansion → Terraform, HL7, X12, Avro, Protobuf.
• Feedback loops → Let users mark gaps as valid/invalid, strengthening future detection.
• CI/CD integration → Semantic gap detection as a pre-merge check, like linting or unit tests.
• Visualization upgrades → Network graphs of artifact interdependencies, root cause explanations, alerts.
• Enterprise adoption → Integration with governance/data catalog tools, ensuring compliance (e.g., financial reporting layouts).

5. Why This Matters

Semantic gaps aren’t trivial — they’re costly. Industry studies estimate that 60–70% of debugging time is spent on misaligned assumptions rather than pure logic errors. Bridging these gaps early not only reduces operational risk but also frees human engineers to focus on innovation, not archaeology.

KonveyN2AI is one attempt to make systems more self-aware — surfacing their hidden assumptions before those assumptions break.

🧩 Lessons Learned

• Dimensionality reduction (PCA) was crucial to cut cost without losing similarity accuracy.
• Caching & retry logic matter more than expected — real-world pipelines need robustness.
• Hybrid rules + AI outperform pure LLM scoring in reliability.

🔭 What’s Next?

• Support more artifact types
• Improve dashboards with richer visualizations
• Add user feedback loops for validation
• Deploy into enterprise pipelines for real-time monitoring

📂 Try It Yourself

The project is open on GitHub: KonveyN2AI-BigQuery

👉 Clone it, run the pipeline, and explore how BigQuery vector search can help surface hidden knowledge in your systems.

✨ Closing

We believe knowledge gaps don’t just slow down systems — they slow down people. With AI + BigQuery, we can start closing them — natively, scalably, and cost-effectively.

Let us know if you’ve faced similar challenges. We’d love to hear your stories, learn from your struggles, and see how others are approaching this space. Your feedback is the single most valuable thing we can get right now.

If you found this interesting, give the repo a star ⭐, share this post, and drop a comment. Let’s build this together.

— KonveyN2AI is our first step. With your stories and feedback, the next steps could be even bigger.

Connect with us:

Nikhil Damacherla | Neeharika Vemulapati

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI