DocAssist

A local document Q&A app. Upload PDFs or text files and ask questions about them. Answers are generated by Llama 3.1 8B running on your GPU and include the source document.

Features

• Drag-and-drop upload for PDF, TXT, and MD files
• Answers with source citations
• Runs fully offline with Ollama, no API keys needed
• Five search backends you can switch between: Python, NumPy, C++, multithreaded C++ (OpenMP), and GPU (PyTorch CUDA)
• Benchmarks for search speed and LLM speed

Tech Stack

• Frontend: Streamlit
• LLM: Llama 3.1 8B via Ollama
• Embeddings: nomic-embed-text
• Search: NumPy, C++17 with pybind11 and OpenMP, PyTorch CUDA
• Other: pypdf

How It Works

1. Uploaded files are split into overlapping chunks (800 characters, 150 overlap)
2. Each chunk is converted to a 768-dimensional embedding
3. Questions are embedded the same way and compared to every chunk with cosine similarity
4. The top 4 chunks are sent to the LLM, which answers using only that context

Installation

Requirements

• Windows 10/11
• Python 3.12+
• NVIDIA GPU
• Ollama
• Visual Studio Build Tools (Desktop development with C++)

Setup

# Clone the repo
git clone https://github.com/oracl-ee/docassist.git
cd docassist

# Download the models
ollama pull llama3.1:8b
ollama pull nomic-embed-text

# Create a virtual environment
python -m venv .venv
.venv\Scripts\activate

# Install dependencies
python -m pip install -r requirements.txt
python -m pip install torch --index-url https://download.pytorch.org/whl/cu128

# Build the C++ extension
python setup.py build_ext --inplace

Usage

Start the web app:

python -m streamlit run app_ui.py

Command-line version:

python main.py ask "What is a warp?" --backend gpu
python main.py chat

Run tests and benchmarks:

python tests/test_backends.py
python -m bench.bench_search
python -m bench.bench_llm

LLM speed

Project Structure

docassist/
├── app/
│   ├── loader.py       # Reads PDF, TXT, and MD files
│   ├── chunker.py      # Splits text into chunks
│   ├── embedder.py     # Creates embeddings
│   ├── store.py        # Saves and loads the index
│   ├── search.py       # Search backends
│   └── llm.py          # LLM prompts and streaming
├── cpp/
│   └── fastsearch.cpp  # C++ search module
├── bench/              # Benchmarks
├── tests/              # Tests
├── app_ui.py           # Streamlit app
├── main.py             # CLI
└── setup.py            # Builds the C++ extension

Troubleshooting

• "An Application Control policy has blocked this file": use python -m pip and python -m streamlit instead of pip and streamlit.
• First answer is slow: the model is loading into VRAM. After that, it stays loaded for 30 minutes.

Roadmap

• Approximate nearest neighbor search (HNSW / FAISS) for large document sets
• Better chunking (split on sentences instead of characters)
• Evaluation set to measure answer accuracy

License

MIT

Cellular Automaton Models of Traffic Flow

Senior capstone project (Mathematics, Fall 2026).

This project designs new cellular automaton (CA) rules for vehicular traffic, compares them against the classic Nagel–Schreckenberg (NaSch) model, and studies how traffic behavior (free flow, phantom jams, phase transitions) changes as the rules and the road geometry change.

The model

A road is a ring of L cells. Each cell is empty or holds one car with an integer speed 0 … v_max. At every time step, all cars update simultaneously using only local information.

Baseline: NaSch (1992)

1. Accelerate: v = min(v + 1, v_max)
2. Brake: v = min(v, d) (where d = empty cells ahead)
3. Randomize: with probability p, v = max(v − 1, 0)
4. Move: x = (x + v) mod L

New rules: ADSD (Anticipating Driver with Startup Delay)

Each car also looks at the car ahead: its speed v_f and its gap d_f.

Key design property: setting α = 0 and p0 = p recovers NaSch exactly. Every difference between the models can therefore be traced to a single switch (anticipation or startup delay).

Collision-freeness: the car ahead always moves at least g_f cells, so moving at most d + g_f cells is safe. The code also verifies this numerically at every step.

Results so far

The fundamental diagram (flow vs. density) for four rule sets, turning each new rule on separately:

• Anticipation lets cars follow more closely, since each driver accounts for the car ahead also moving.
• Startup delay makes jams "stickier": stopped cars restart slowly, so congestion forms large, long-lived jams that move backward along the road (visible as dark diagonal bands in the space-time diagram above).

Repository structure

Running it

python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -r requirements.txt

python check_rules.py            # tests + small trace table
python run_highway_comparison.py # writes figures/ (about 1 minute)

Parameters (L, v_max, p, p0) are set near the top of run_highway_comparison.py.

Roadmap

• NaSch baseline and ADSD rules on a ring highway
• Verification and rule-by-rule comparison
• Parameter sweeps and phase-transition analysis
• T-intersection geometry (yielding rule)
• Merge / on-ramp geometry (gap-acceptance rule)
• Mean-field model for flow vs. density under ADSD
• Formal collision-freeness proof for every geometry

References

1. K. Nagel and M. Schreckenberg, "A cellular automaton model for freeway traffic," J. Phys. I France 2 (1992), 2221–2229.
2. D. Chowdhury, L. Santen, and A. Schadschneider, "Statistical physics of vehicular traffic and some related systems," Physics Reports 329 (2000), 199–329.
3. R. Barlovic, L. Santen, A. Schadschneider, and M. Schreckenberg, "Metastable states in cellular automata for traffic flow," Eur. Phys. J. B 5 (1998), 793–800.

ESG Emissions Reporting Platform

🚧 Work in progress. The front end is functional. The back end is under active development.

A web app that helps companies estimate their greenhouse-gas emissions and prepare for climate disclosure rules such as California SB 253 (Climate Corporate Data Accountability Act).

Features

Working now (front end) - Landing page with information pages: About SB 253, FAQ, and a Compliance Guide - Step-by-step data entry: company details, electricity, natural gas, and vehicle fuels - Real-time form validation, including ZIP code / city verification via the Zippopotam.us API - Review step and emissions dashboard - Progress saved in the browser, so users can leave and come back

Planned (back end) - REST API with Express - Database storage for company profiles and emissions data - User accounts and authentication - Server-side emissions calculations using published emission factors - Exportable reports

Tech stack

Running locally

Requires Node.js 18 or newer.

Front end

cd client
npm install
npm run dev

Then open the local URL Vite prints (usually http://localhost:5173).

Back end

cd server
npm install
node src/server.js

Health check: http://localhost:3000/api/health

Project structure

esg-saas/
├── client/                 # React front end
│   └── src/
│       ├── pages/          # Landing, dashboard, info pages
│       ├── components/     # Forms (electricity, natural gas, fuels, review)
│       └── context/        # Shared form state
└── server/                 # Express API (in progress)
    └── src/server.js

🥢

A desktop version of the hand game Chopsticks, built for fun in Java Swing. Play against a friend or against a computer opponent that uses minimax search.

How to play

• Each player starts with 1 finger on each hand.
• On your turn, tap one of the opponent's hands with one of yours. Their hand gains as many fingers as your tapping hand has.
• A hand that reaches exactly 5 is out. Totals above 5 wrap around (for example, 4 + 3 = 2).
• Lose both hands, or have no legal move, and you lose.

Modes

• Player vs. Player: two people on one computer.
• Player vs. Computer: a minimax AI with selectable difficulty.

Running it

Requires Java 17 or newer.

• IntelliJ IDEA: open the folder and run GameLauncher.
• Command line: bash javac -d out src/*.java java -cp out GameLauncher

Code overview