kompany

Turn unstructured company files into an interactive, real-time knowledge graph.

Comment

Inspiration

Modern organizations accumulate knowledge at an overwhelming rate, yet they are suffering from severe "institutional amnesia." Sprints are lost in closed Linear issues, design rationale is buried in Slack threads, and handbooks go out of date the minute they are written. Traditional knowledge management tools fail because they require active curation which developers hate.

We were inspired to build Kompany (Company Brain) to solve this: a zero-overhead, self-structuring organizational memory engine. We wanted to build a system that works like a human brain: quietly observing event streams, drawing connections, and building an associative map of the organization without anyone writing a single SQL schema.

What it does

Kompany is a B2B SaaS platform that continuously ingests unstructured organization data (Markdown files, project specifications, team directories) and inductively constructs an interactive Organizational Memory Graph in real-time.

  • Floating Chat Engine: A minimalist, distraction-free conversational panel on the left that allows team members to query the company brain about goals, projects, history, and people.
  • Obsidian-Style SVG Force Graph: A live force-directed network on the right that maps entities (products, frameworks, people, county clients, partners) and their relationships. Clicking or hovering over nodes pops up detailed relationship context cards.
  • Interactive File Uploader: A circular attachment widget that lets users upload raw Markdown or text files. The backend automatically extracts entities and merges them into the memory map on the fly.

How we built it

  • Frontend & UI Design (Interactive Visualizations): Engineered using Next.js, React, and vanilla CSS. We built a responsive dashboard where a translucent floating chat interface coordinates with an active SVG force-directed graph canvas. When a user uploads a document, the Next.js proxy route fetches serialized graph updates, and the d3-force simulation loops calculate node physics, color-clustering, and repositioning dynamically. Click and hover listeners bind coordinates to floating relationship detail cards on node selection.
  • Cognition & GraphRAG (Incremental Mapping): Built on the LightRAG framework. When text is submitted, LightRAG's entity-extraction engine parses the raw markdown to discover Subject-Predicate-Object semantic triples. These relationships are written incrementally to a local NetworkXStorage graph database, which instantly serializes the new node structures to update the SVG canvas.
  • AWS Database Backend (Vector Retrieval): Utilizes AWS Aurora PostgreSQL (configured with the pgvector extension). The system converts raw document texts and queries into 1536-dimension embeddings using OpenAI models. Aurora PostgreSQL indexes these vectors to run semantic similarity checks, allowing the agent to retrieve historical context and link documents to the graph.
  • Agent Runtime (Scheduling & Execution): Built on the EVE framework for TypeScript. EVE manages durable, session-aware agent runs, binding the frontend forms to custom background tools (ingest_event and query) while running background cron tasks to sync with external project tools.

Challenges we ran into

  • State Polling Snapping Canvas: In early builds, D3 force simulations snapped or vanished when background data-syncing polled every 10 seconds. The interval was closing over outdated React state variables. We fixed this by migrating to functional state update patterns (setNodes(prev => ...)) to compare and merge newly-fetched nodes while retaining existing coordinate simulations.
  • FastAPI Ingestion Timeouts: Initial document extractions took over 60 seconds, triggering Next.js HTTP proxy timeouts. We redesigned the FastAPI /ingest routes to execute RAG insertions asynchronously using asyncio.create_task and return immediate queue acknowledgments.
  • Vercel Cron hobby Limits: Vercel Hobby accounts block cron jobs running more than once per day. We restructured our EVE Linear cron scheduler from 15-minute intervals to a compliant once-daily midnight execution format.

Accomplishments that we're proud of

  • Designing a visual design system with zero template placeholders giving judges a premium dark mode dashboard that feels responsive and alive.
  • Implementing client-side HTML5 FileReader pipelines that feed text directly into EVE's custom ingest_event tool.
  • Achieving clean, real-time graph updates that render node-clustering logic dynamically as document uploads complete.

What we learned

We learned the extreme power of combining semantic Vector RAG with structured Graph RAG (GraphRAG). While vectors are excellent for retrieving single blocks of text, graphs excel at connecting the dots across separate documents (for example, linking a developer's profile to the database engine they use, and connecting that database engine to the client they designed it for).

What's next for kompany

  • Linear & Slack Event Streams: Enabling OAuth webhooks to ingest live organization events automatically.
  • Row-Level Tenant Isolation: Partitioning PGVector tables in AWS Aurora to support secure multi-tenant hosting.
  • Evolving Belief Systems: Empowering the agent to deduce corporate beliefs (e.g. "our team prioritizes local-first storage") from Linear decisions, warning developers when pull requests conflict with company philosophies.

Built With

Share this project:

Updates