ai-pdf-chatbot-langchain

Processes uploaded PDF files through a LangGraph-orchestrated ingestion graph that extracts text, chunks documents, generates vector embeddings via OpenAI's embedding API, and persists them to Supabase's pgvector-enabled PostgreSQL database. Uses LangChain's document loaders and text splitters to handle variable PDF structures and sizes, with configurable chunking strategies to balance retrieval granularity and context window efficiency.

Implements a LangGraph-based retrieval graph that accepts natural language queries, routes them through a decision node (using an LLM to determine if document context is needed), performs vector similarity search against embedded PDFs when relevant, and returns ranked results with source attribution. Uses cosine similarity on pgvector embeddings and implements a configurable similarity threshold to filter low-confidence matches, reducing hallucination by grounding responses in actual document content.

Extracts and indexes document metadata (filename, upload timestamp, page count, chunk count) alongside embeddings, enabling filtering and sorting of search results by document properties. Stores metadata as JSON in the pgvector table, allowing SQL queries to filter by document attributes before or after similarity search. Implements automatic metadata generation during ingestion, with optional user-provided metadata (tags, categories) for custom filtering.

Implements error boundaries at multiple layers (API routes, React components, LangGraph nodes) to catch and handle failures gracefully. API routes return meaningful HTTP status codes and error messages; React components display error UI without crashing; LangGraph nodes implement retry logic and fallback paths. Uses try-catch blocks and error callbacks to transform backend exceptions into user-friendly messages, preventing technical errors from reaching end users.

Organizes the application as a monorepo with separate frontend (Next.js) and backend (Node.js/LangGraph) workspaces, coordinated by Turborepo for efficient builds and dependency management. Turborepo caches build artifacts and skips rebuilds for unchanged packages, reducing build time. Shared types and utilities are extracted to a common package, enabling type-safe communication between frontend and backend without duplication.

Generates LLM responses in real-time using OpenAI's streaming API, with each token streamed to the frontend via Server-Sent Events (SSE). Maintains a parallel metadata stream that tracks which source documents contributed to each response section, enabling inline source attribution in the UI. Uses LangChain's streaming callbacks to intercept token events and map them back to retrieved document chunks, providing transparent provenance for every answer.

Maintains conversation history in frontend state (React hooks) and backend session storage, with automatic context window management that truncates or summarizes older messages to fit within the LLM's token limit. Uses a sliding window strategy where recent messages are always included, and older messages are progressively dropped or compressed based on token count. Implements conversation reset and context clearing to allow users to start fresh without losing document embeddings.

Orchestrates complex document processing and query workflows using LangGraph's directed acyclic graph (DAG) execution model, where each node represents a discrete step (PDF load, chunk, embed, retrieve, generate) and edges define control flow. Implements conditional routing nodes that branch execution based on query type or document availability, with built-in error handling and state persistence. Uses LangGraph's compiled graph execution to optimize performance and enable step-by-step debugging.

Implements a Next.js API route that accepts multipart/form-data file uploads, validates file type and size on both client and server, and streams upload progress back to the UI via chunked responses. Uses React hooks to manage upload state (in-progress, success, error) and displays real-time progress bars. Integrates with the ingestion graph to trigger document processing immediately after upload completes, with error boundaries to handle processing failures gracefully.

Abstracts embedding model selection through a configuration layer that supports multiple providers (OpenAI, Hugging Face, local models) without changing application code. Uses LangChain's embedding interface to swap implementations at runtime based on environment variables or configuration files. Enables cost optimization (using cheaper models for non-critical embeddings) and privacy compliance (using local models instead of cloud APIs) through simple configuration changes.

Integrates with Supabase's PostgreSQL database with pgvector extension to store document embeddings, metadata, and retrieval indices. Uses SQL queries with pgvector's similarity operators (<->, <#>) to perform vector similarity search directly in the database, avoiding separate vector DB infrastructure. Implements automatic index creation for performance optimization and handles vector dimension validation to ensure consistency across embeddings.

Implements Next.js API routes that act as a thin HTTP layer between the frontend and backend LangGraph services. Routes handle request parsing, error transformation, and response formatting, abstracting away backend complexity from the frontend. Uses Next.js middleware for authentication, rate limiting, and request logging. Supports both request-response and streaming patterns, with automatic error handling that converts backend exceptions into HTTP status codes.

Manages chat UI state using React hooks (useState, useCallback) to track messages, loading states, and error conditions. Implements a message array that stores both user and assistant messages with metadata (timestamp, source attribution, error status). Uses useCallback to memoize event handlers and prevent unnecessary re-renders. Integrates with the streaming API to append tokens to the current message in real-time, creating a responsive chat experience without full-page re-renders.