AI-powered co-author discovery platform. Describe your research, get ranked collaborator matches, handpick scholars, and explore ideas through multi-scholar chat.

Built for HackIllinois 2026.

Hosted in: https://papertech-a30fb500.aedify.ai/ .tech domain name: http://pap3r.tech/

• Node.js 18+ — nodejs.org
• Python 3.11+ — python.org
• uv — curl -LsSf https://astral.sh/uv/install.sh | sh
• Docker — for Actian VectorAI DB (optional, mock data works without it)

git clone <repo-url> && cd paper.tech
chmod +x dev.sh
./dev.sh

This installs all dependencies and starts both servers:

• Frontend: http://localhost:5173
• Backend API: http://localhost:8000
• Swagger UI: http://localhost:8000/docs

Frontend (React + Vite)
    │
    ▼  /api proxy
FastAPI Backend
    │
    ├── Actian VectorAI DB ── scholar/paper embeddings, ANN search, geo filter
    ├── Short-term memory ─── in-memory sliding window (last 6 exchanges)
    ├── Long-term memory ──── Supermemory SDK (cross-session semantic recall)
    ├── LLM inference ─────── Qwen3-4B on Modal GPU (chat, ideas, RAG)
    ├── Email generation ──── Gemini 2.5 Flash (collaboration emails)
    └── Data source ───────── OpenAlex API (250M+ papers, author metadata)

The chat system uses a two-layer memory approach:

Flow for each chat message:

1. Supermemory searches for relevant long-term context (scholar data, past sessions)
2. Recent history window (last 6 turns) is pulled from in-memory cache
3. Both are assembled into the prompt sent to the LLM
4. The exchange is stored in both layers (history cache + Supermemory)

Scholar matching uses a weighted composite score:

Score = 0.2 * Jaccard(topics) + 0.6 * Cosine(embeddings) + 0.2 * BibCoupling(citations)

• Jaccard: Topic keyword overlap between your query and the scholar's research areas
• Cosine: Semantic similarity via ANN search on all-MiniLM-L6-v2 embeddings in Actian VectorAI DB
• BibCoupling: Co-citation graph edge weight from shared reference networks

cd backend
uv sync
uv run uvicorn app.main:app --reload --port 8000

cd frontend
npm install
npm run dev

Start the vector database with Docker:

docker compose up -d vectoraidb

Then initialize schema and ingest data from OpenAlex:

cd backend/db-scripts
python schema.py              # create collections
python ingest.py              # fetch 500 scholars from OpenAlex, embed, store

When the DB is running, /api/match and /api/scholars automatically use real vector search. When unavailable, they fall back to mock data.

All config lives in a single .env at the project root.

All routes have mock fallbacks, so the app runs without any keys set.

Deploy the Qwen3-4B LLM and MiniLM embeddings to Modal:

cd backend
uv run modal setup              # one-time auth
uv run modal deploy modal_app.py

Add the printed endpoint URLs to your .env:

MODAL_LLM_ENDPOINT=https://<username>--paper-tech-llmserver-v1-chat-completions.modal.run
MODAL_EMBED_ENDPOINT=https://<username>--paper-tech-embedserver-embed.modal.run

Features: A10G GPU, vLLM serving, GPU memory snapshots for fast cold starts, persistent HuggingFace cache volume.

Compare multi-turn context retention across 5 setups:

cd backend

# Run benchmark (warms up endpoints first, excludes cold start from results)
uv run python -m benchmark.benchmark

# Generate plots from saved results
uv run python -m benchmark.plots

Results and plots saved to backend/benchmark/results/.

The backend includes a Dockerfile for deployment on Aedify:

1. Connect the GitHub repo in the Aedify dashboard
2. Set the root directory to backend/
3. Add all environment variables from .env
4. Deploy — Aedify will build from the Dockerfile and serve on a live URL

The frontend can be deployed as a separate Aedify app with root directory frontend/.

1. Create a feature branch: git checkout -b feature/your-feature
2. Make changes, commit, push: git push -u origin feature/your-feature
3. Open a PR to main

• Backend: uv add <package> (from project root)
• Frontend: cd frontend && npm install <package>

paper.tech/
├── frontend/                 # React + Vite SPA
│   ├── src/
│   │   ├── api/client.js     # Axios API client
│   │   ├── components/       # ScholarCard, ChatPanel, GeoFilter, etc.
│   │   └── pages/            # LandingPage, ResultsPage, EmailDraftPage
│   └── vite.config.js        # /api proxy to backend
├── backend/
│   ├── app/
│   │   ├── main.py           # FastAPI app, CORS, router registration
│   │   ├── config.py         # Pydantic BaseSettings
│   │   ├── vectordb.py       # Actian VectorAI DB client + composite scoring
│   │   ├── supermemory.py    # Hybrid memory (short-term + Supermemory)
│   │   ├── mock_data.py      # Dev fallback data
│   │   ├── models/schemas.py # Pydantic request/response models
│   │   ├── routers/          # match, scholars, handpick, chat, graph, ideas
│   │   └── routes/email.py   # Email generation (Gemini 2.5 Flash)
│   ├── db-scripts/           # Actian schema, OpenAlex ingest, scoring
│   ├── benchmark/            # Multi-turn context retention benchmark
│   ├── modal_app.py          # Modal deployment config
│   └── Dockerfile            # Aedify deployment
├── docker-compose.yml        # Actian VectorAI DB container
├── pyproject.toml            # Python dependencies (uv)
├── dev.sh                    # One-command startup
└── .env                      # Environment variables (gitignored)