Skip to content

vineetsarpal/re-ink

BranchesTags

Repository files navigation

re-ink

Automated Reinsurance Contracts & Parties creation using Agentic Document Extraction

re-ink is a full-stack web application that streamlines reinsurance contract management by automatically extracting contract details and party information from uploaded documents using AI-powered document extraction.

Recognition

Finalist in the LandingAI Financial AI Hackathon Championship 2025

Demo

Watch the demo

Features

  • 📄 Document Upload: Upload PDF and DOCX reinsurance contract documents
  • 🤖 AI Extraction: Automatic extraction of contract terms and parties using LandingAI
  • ✅ Review Workflow: Review and edit AI-extracted data before creating records
  • 🔎 Source-Grounded Review: Every extracted field links back to the passage and page it came from, so reviewers can verify AI output at a glance
  • 📊 Contract Management: Full CRUD operations for reinsurance contracts
  • 👥 Party Management: Manage parties (cedants, reinsurers, brokers)
  • 🔍 Search & Filter: Find contracts and parties quickly
  • 📈 Dashboard: Overview of contracts and parties with statistics
  • 🧪 Sample Extraction Mode: Seed mock data to test the workflow without LandingAI
  • 🤝 AI Agent Guidance: LangChain/LangGraph agents surface intake insights and automated reviews

Sample Documents

Two sample PDFs are bundled with the frontend and available directly in the Upload page UI — just click a sample card to load it, no setup required.

Technology Stack

Backend

  • FastAPI: Modern Python web framework
  • SQLAlchemy: ORM for database operations
  • PostgreSQL: Relational database
  • LandingAI: Agentic document extraction API
  • Alembic: Database migrations

Frontend

  • React 18: UI framework
  • TypeScript: Type-safe JavaScript
  • Vite: Fast build tool
  • React Router: Client-side routing
  • React Query: Server state management
  • Axios: HTTP client

Architecture

┌────────────────────────────────────────────────────────────────────────────┐
│                              USER / BROWSER                                │
└───────────────────────────────┬────────────────────────────────────────────┘
                                │
                    ┌───────────▼───────────┐
                    │     React Frontend    │
                    │  - Upload & Review UI │
                    │  - AI Insight Panels  │
                    └───────────┬───────────┘
                                │  HTTP/REST
                    ┌───────────▼───────────┐
                    │     FastAPI Backend   │
                    │                       │
                    │ /api/documents        │
                    │ /api/review           │
                    │ /api/agents           │
                    └───┬──────────────┬────┘
                        │              │
                ┌───────▼───┐      ┌───▼───────────────┐
                │ Document  │      │ Agent Service     │
                │ Service   │      │ (LangChain/Graph) │
                │ (LandingAI│      │ - Guided Intake   │
                │  workflow)│      │ - Contract Review │
                └────┬──────┘      └────┬──────────────┘
                     │                  │
        ┌────────────▼────────┐         │
        │ LandingAI ADE API   │         │
        │ Parse & Extract     │         │
        └────────────┬────────┘         │
                     │                  │
        ┌────────────▼────────────────┐ │            ┌─────────────────┐
        │ PostgreSQL                  │◄┼────────────┤ LangChain LLM   │
        │ - Contracts & Parties       │ │  prompts   │  (OpenAI, Ollama│
        │ - Extraction Jobs           │ │            │   or offline)   │
        └─────────────────────────────┘ │            └─────────────────┘
                                        │
                            (insights returned to frontend)

Quick Start

Rapid Start via Makefile

The repo includes a Makefile so you can bootstrap both services quickly:

# Install backend + frontend dependencies
make setup

# Copy and edit environment files (run once)
cp backend/.env.example backend/.env
cp frontend/.env.example frontend/.env

# Launch both dev servers (Ctrl+C stops both)
make dev

Use make backend-dev or make frontend-dev to run either side individually, and make backend-install / make frontend-install to refresh dependencies. make sync-version copies the root VERSION file into backend/ (included automatically in make setup).

Prerequisites

  • uv (Python package & project manager)
  • Python 3.13+ (uv can install this for you)
  • Node.js 18+
  • PostgreSQL 12+
  • LandingAI API key

Backend Setup

Dependencies are managed with uv (pyproject.toml + uv.lock). uv sync creates the .venv and installs the locked dependencies; uv run executes commands inside it, so there's no virtualenv to activate manually.

cd backend

# Install dependencies (creates .venv; dev group included by default)
uv sync

# Configure environment
cp .env.example .env
# Edit .env with your settings

# Set up database
createdb reink_db
uv run alembic upgrade head   # builds schema from migrations on a fresh DB

# For an existing DB previously created by create_all() — stamp it first (one-time):
# uv run alembic stamp 0001_baseline && uv run alembic upgrade head

# Run server (auto-reload; entrypoint is configured in pyproject.toml)
uv run fastapi dev
# or use: make backend-dev

Backend will be available at http://localhost:8000 API docs at http://localhost:8000/docs

Frontend Setup

cd frontend

# Install dependencies
npm install

# Configure environment
cp .env.example .env
# Edit .env with backend URL

# Run development server
npm run dev
# or use: make frontend-dev

Frontend will be available at http://localhost:3000

Project Structure

re-ink/
├── VERSION                   # Single source of truth for app version
├── backend/                  # FastAPI backend
│   ├── app/
│   │   ├── api/             # API endpoints
│   │   ├── core/            # Configuration (reads VERSION file)
│   │   ├── db/              # Database setup
│   │   ├── models/          # SQLAlchemy models (Contract, Party, ExtractionJob)
│   │   ├── schemas/         # Pydantic schemas
│   │   ├── services/        # Business logic
│   │   └── main.py          # Application entry
│   └── pyproject.toml
├── frontend/                 # React frontend
│   ├── public/
│   │   └── samples/         # Bundled sample PDFs (selectable in UI)
│   ├── src/
│   │   ├── components/      # React components
│   │   ├── pages/           # Page components
│   │   ├── services/        # API client
│   │   ├── types/           # TypeScript types
│   │   └── styles/          # CSS styles
│   └── package.json

Workflow

  1. Upload: User uploads a reinsurance contract document (PDF or DOCX)
  2. Extract: System sends document to LandingAI for AI-powered extraction
  3. Process: AI extracts contract details, dates, financial terms, and party information
  4. Review: User reviews and edits the extracted data in a user-friendly form, with source evidence showing the page/passage behind each grounded field
  5. Approve: User approves the data, creating Contract and Party records
  6. Manage: Contracts and parties can be viewed, searched, and managed

API Endpoints

Documents

  • POST /api/documents/upload - Upload a document and start extraction in the background
  • GET /api/documents/status/{job_id} - Check extraction status (supports processing, completed, failed)
  • GET /api/documents/results/{job_id} - Retrieve parsed extraction results when a job is complete
  • GET /api/documents/file/{job_id} - Stream the original uploaded document for the review preview panel (404 for mock jobs)

Contracts

  • GET /api/contracts/ - List contracts (supports status, contract_type, skip, limit filters)
  • POST /api/contracts/ - Create a contract
  • GET /api/contracts/{id} - Get contract details with associated parties
  • PUT /api/contracts/{id} - Update contract fields
  • DELETE /api/contracts/{id} - Soft delete a contract
  • POST /api/contracts/{id}/parties/{party_id} - Link a party to a contract with a role
  • DELETE /api/contracts/{id}/parties/{party_id} - Remove a party association from a contract

Parties

  • GET /api/parties/ - List parties (supports is_active, skip, limit)
  • POST /api/parties/ - Create a party
  • GET /api/parties/{id} - Get party details
  • PUT /api/parties/{id} - Update party fields
  • DELETE /api/parties/{id} - Soft delete a party
  • GET /api/parties/search/by-name - Search parties by partial name match

Review

  • POST /api/review/approve - Approve extracted data
  • POST /api/review/reject/{job_id} - Reject extraction

Agents

  • POST /api/agents/intake - Run the guided intake LangChain agent for an extraction job
  • POST /api/agents/review - Generate an automated review for a contract

System

  • GET /api/system/config - Return agent configuration flags (e.g., offline mode) for the frontend

Development

See detailed development guides:

Configuration

Backend (.env)

DATABASE_URL=postgresql://user:password@localhost:5432/reink_db
WORKOS_CLIENT_ID=client_...
WORKOS_API_KEY=sk_...             # Optional; not needed for access-token validation
LANDINGAI_API_KEY=your_landingai_api_key   # Optional — users can supply their own key in the UI (BYOK)
LANDINGAI_PARSE_URL=https://api.va.landing.ai/v1/ade/parse
LANDINGAI_EXTRACT_URL=https://api.va.landing.ai/v1/ade/extract
LANDINGAI_PARSE_MODEL=dpt-2-latest
LANDINGAI_EXTRACT_MODEL=extract-latest
MAX_UPLOAD_SIZE=52428800
UPLOAD_DIR=./uploads
ALLOWED_ORIGINS=["http://localhost:3000","http://localhost:5173"]
LOG_LEVEL=INFO
LLM_PROVIDER=openai               # "openai" or "ollama"
OPENAI_API_KEY=your_openai_key    # Only needed when LLM_PROVIDER=openai
AGENT_MODEL=gpt-4o-mini
AGENT_TEMPERATURE=0.1
AGENT_OFFLINE_MODE=false          # Set true to skip LLM calls entirely
OLLAMA_BASE_URL=http://localhost:11434  # Only needed when LLM_PROVIDER=ollama
OLLAMA_MODEL=llama3.1
  • LANDINGAI_API_KEY is optional on the server — users can enter their own key directly in the Upload UI (BYOK). If neither is set, the upload will be rejected with a clear error.
  • WORKOS_CLIENT_ID drives WorkOS issuer and JWKS validation for protected API routes.
  • LLM_PROVIDER selects the agent LLM backend; set AGENT_OFFLINE_MODE=true to skip LLM calls entirely.
  • ALLOWED_ORIGINS supports JSON array notation (shown above) or a comma-separated list. In production, set this to your deployed frontend URL.
  • The app version is read from the VERSION file at the repo root — do not set APP_VERSION in .env.
  • CI/CD: The deploy workflow runs uv run alembic upgrade head before deploying. The GitHub Actions secret DATABASE_URL must be configured in the repository settings for migrations to run in CI.

Frontend (.env)

VITE_API_BASE_URL=http://localhost:8000/api
VITE_WORKOS_CLIENT_ID=client_...
VITE_WORKOS_REDIRECT_URI=http://localhost:3000/auth/callback

License

See LICENSE file for details.

Contributing

This project is designed for insurance and reinsurance companies to streamline contract management workflows. Contributions are welcome!

Support

For issues, questions, or feature requests, please open an issue on the project repository.

About

AI-powered Reinsurance Contracts & Parties management

re-ink.pages.dev

Topics

reinsurance document-extraction langchain-python agentic-ai landing-ai

Resources

Readme

License

Apache-2.0 license
Activity

Stars

6 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages