GraphMind is a full-stack knowledge graph project that converts unstructured content such as documents,
notes, articles, and URLs into connected, queryable intelligence. Instead of only keyword matching, it extracts
entities and relationships so users can explore connections like who appears across documents and which organizations
they are linked to.
Problem It Solves
Manual research across scattered files does not scale and usually forces repeated reading of the same material.
GraphMind automates structured extraction and gives teams relationship-first queries, making research synthesis,
due diligence, and competitive intelligence faster and more reliable.
Current Status
GraphMind was originally built as a VM-hosted Docker Compose backend (FastAPI, Celery workers, RabbitMQ, Redis,
Neo4j) with a Next.js frontend. While Oracle, AWS, and GCP all have free tiers, each still requires a card on file
at signup for abuse prevention. Since I wanted a path that avoids entering payment details entirely while still
showcasing the product, I rebuilt the deployment shape into a no-card demo architecture.
System Architecture
Original Build (VM + Docker Compose)
- Frontend: Next.js + TypeScript web app for ingesting content and exploring graph results.
- API Layer: FastAPI service for ingest endpoints, graph reads, and job status responses.
- Async Processing: Celery workers run long extraction jobs off-request.
- Queue + State: RabbitMQ handled task dispatch and Redis stored task/job status.
- Graph Storage: Neo4j persisted entities and relationships for traversal queries.
- Infra: Single cloud VM running Docker Compose services for API, workers, queue, cache, and graph DB.
No-Card Demo Build (Current Showcase)
- Frontend Hosting: Vercel hosts the Next.js app with no additional account setup required for me.
- Graph Database: Neo4j AuraDB Free provides managed graph storage without requiring a card.
- Cache/State: Upstash Redis Free stores short-lived state for async demo flows without card entry.
- Background Flow: Workflow-style orchestration replaces always-on RabbitMQ/Celery daemons for demo execution.
- LLM Extraction: OpenAI still performs entity/relationship extraction from chunked unstructured input.
- Goal: Preserve the product narrative and technical depth while avoiding paid infrastructure wiring.
Technology and Service Breakdown
- Next.js: Main web framework used to build the GraphMind UI and page routing.
- TypeScript: Added static typing for safer API contracts and more maintainable frontend logic.
- React: Component model for ingestion forms, status views, and graph exploration screens.
- react-force-graph-2d: Renders an interactive force-directed knowledge graph users can explore visually.
- Tailwind CSS: Utility-first styling to ship consistent UI quickly.
- FastAPI: Python API layer for ingest requests, status polling, and graph query endpoints.
- Uvicorn: ASGI runtime used to serve FastAPI endpoints in development and deployment.
- Python: Core service language for extraction pipelines and backend orchestration code.
- OpenAI (function calling): Converts raw text chunks into structured entities and relationship triples.
- Neo4j: Primary graph database for storing and querying linked entities.
- APOC: Neo4j procedures used to simplify graph operations and relationship handling.
- Celery (original architecture): Worker framework for async document-processing tasks.
- RabbitMQ (original architecture): Message broker that queued Celery jobs.
- Redis (original architecture): Result backend and job-state cache for worker progress.
- Docker + Docker Compose (original architecture): Ran API, workers, queue, cache, and graph DB as one stack.
- GCP / AWS / Oracle VM (original deployment target): Host for long-running worker infrastructure, but still card-gated at signup.
- Vercel (current demo): Hosts the stateless frontend and demo-facing app routes.
- Neo4j AuraDB Free (current demo): Managed graph database with no card requirement.
- Upstash Redis Free (current demo): Managed Redis for lightweight state without card entry.
- Workflow-style serverless orchestration (current demo): Replaces always-on queue workers for no-card demo execution.
- GitHub: Source control, collaboration, and project documentation hosting.
Why Graph over Basic RAG/Search
RAG and search tools are excellent for retrieving relevant chunks, but they still treat documents as mostly isolated units.
GraphMind models the relationships between entities and facts, so insights come from the connections across sources, not only
similarity scores within individual chunks.