Michigan Unified E-Filing System (MUEFS)

Copyright (c) 2026 Thomas Cedoz. Licensed under AGPL-3.0-or-later.

A modern, open-source statewide e-filing platform for Michigan courts. Designed to unify filing across all of Michigan's courts into a single, standards-compliant portal.

Live demo: https://webmcp.tomcedoz.com/agent · https://demo.tomcedoz.com · Agent tools: docs/WEBMCP.md

Why this exists: Michigan's current e-filing landscape is fragmented across multiple vendors and systems. Attorneys waste hours navigating incompatible platforms. Self-represented litigants face complex procedures with no guidance. MUEFS is a unified, modern alternative — one login and one interface for filing across Michigan's courts.

MUEFS vs MiFILE

Capability	MiFILE / current landscape	MUEFS (this demo)
Court coverage	Not all courts or case types	Demo portal (seeded courts)
Public docket search	Varies by court; often separate portals	Built-in; no account in demo
Document types	Varies by vendor	MCR-referenced catalog (count from live seed data)
Upload limit	25 MB (SCAO standard)	100 MB
Fee waiver (MCR 2.002)	Payment screen; court must grant	In filing wizard (demo payments)
Motion companions	Filers must know MCR rules	Validates & prompts (MCR 2.119)
File from case docket	Existing-case filing supported	Pre-filled from case detail
Case favorites	Not available	Star cases, quick access
Serve documents only	Varies; often separate workflow	One-click from case docket
Draft autosave	Vendor-dependent	Browser draft recovery
Clerk review tools	Queue tools vary by court	Batch accept, age badges, quick reject reasons
AI agent tools (WebMCP)	Not available	23 role-aware tools + /agent hub
Cost / licensing	Per-transaction vendor fees	AGPL-3.0 (no license fee)

Status: Open source demo — core filing, clerk review, and public docket search work today. CMS integration is a stub until a court JIS/CMS adapter is wired in production.

---

Try It Now

Clone and run the full demo in 4 commands — no Docker, no database setup:

git clone https://github.com/Tzodec1526/MUEFS.git
cd MUEFS/backend
pip install -e ".[test]"
python run_demo.py

• Filing Portal: http://localhost:3000
• API: http://localhost:8000
• API Docs: http://localhost:8000/docs

Log in as an Attorney, Court Clerk, or Self-Represented Litigant, or browse public court records without signing in.

A 60-second attorney walkthrough is in demo/muefs-walkthrough-60s.mp4 (regenerate with scripts/record-walkthrough.ps1).

---

Architecture

• Backend: Python 3.11+ / FastAPI (async)
• Frontend: React 18 + TypeScript + Vite
• Database: PostgreSQL 16 (production) / SQLite (demo)
• Cache/Queue: Redis 7 + Celery
• Object Storage: MinIO S3-compatible (production) / local filesystem (demo)
• Auth: Keycloak OAuth2/OIDC (production) / role-based demo login (demo)
• Containerization: Docker + Docker Compose

Production Setup (Docker)

For a real (non-demo) deployment — secrets, TLS, backups, ClamAV, and the production toggles — follow docs/DEPLOYMENT.md. The commands below bring up the full local stack.

git clone https://github.com/Tzodec1526/MUEFS.git
cd MUEFS
cp .env.example .env
docker-compose up --build

Services:

• Filing Portal: http://localhost:3000
• API: http://localhost:8000
• API Docs: http://localhost:8000/docs
• Keycloak Admin: http://localhost:8080

Project Structure

MUEFS/
├── backend/           # FastAPI backend API
│   ├── app/
│   │   ├── api/       # REST endpoints
│   │   ├── models/    # SQLAlchemy models
│   │   ├── schemas/   # Pydantic schemas
│   │   ├── services/  # Business logic
│   │   └── seed_data.py  # Michigan court data
│   └── tests/         # backend tests (pytest + HTTP smoke)
├── frontend/          # React frontend
│   └── src/
│       ├── components/  # Filing wizard, clerk queue, case search
│       ├── api/         # API client
│       └── styles/      # Global CSS
└── docker-compose.yml

Features

For Attorneys

• Unified filing across Michigan courts from a single login
• MCR-referenced document types (live count on the dashboard) with court rule guidance
• Companion document alerts — system tells you when a motion requires a brief (MCR 2.119), meet-and-confer certification (MCR 2.313), or proposed order
• One-click motion filing — open a case, click "File with Court", and court/case/type are pre-filled
• Case favorites — star cases for quick access across sessions
• Auto-save drafts — never lose work in progress
• Pre-submission validation — catch errors before clerk review

For Self-Represented Litigants

• Guided filing wizard with plain-language instructions
• Fee waiver support (MCR 2.002) built into the payment flow
• Step-by-step process — no legal knowledge of e-filing procedures required

For Court Clerks

• Review queue with batch accept, age tracking, and common rejection reasons
• Document compliance checks — text-searchability, file format, size limits
• Real-time filing status updates with notifications

For Court Administration

• Statewide analytics — filing volumes, processing times, court coverage
• Open source — no vendor lock-in, transparent, community-driven
• Cost savings — one system replaces multiple vendor contracts

For the Public & Press

• Open docket search — look up any non-sealed case by number or party name, no account required
• Public document access — view dockets and download non-confidential filings; sealed cases and confidential documents stay restricted to parties and court staff
• Transparency by default — court records are open by default, protected where the rules require

Development

Backend

cd backend
pip install -e ".[test]"
pytest tests/ -v          # Run full suite (includes HTTP smoke: /health, /docs)
uvicorn app.main:app --reload

Reseeding demo data

Seeding runs once and then skips, so a database keeps old seed data after app/seed_data.py changes. To reseed:

docker compose exec backend python -m app.seed_data --reset   # Docker stack
rm backend/demo.db                                            # run_demo.py reseeds on next start

--reset drops and recreates only the application tables — Keycloak's tables and stored documents are untouched. For a fully clean slate (all volumes, including uploaded documents), use docker compose down -v && docker compose up --build.

Frontend

cd frontend
npm install
npm run dev               # Development server
npx tsc --noEmit          # Type check
npm run build             # Production build

From the repo root you can also run npm run dev (full demo stack), npm test, and npm run lint.

WebMCP

• /agent — tool catalog, workflows, activity feed, example prompts
• Workflows: attorney_motion_workflow, research_case_for_motion, clerk_triage_workflow
• 23 tools, role-filtered (public / filer / clerk)

Guide: docs/WEBMCP.md

Security & Compliance

Opening the public demo's front door never opens the rooms inside — application-layer security is enforced server-side and covered by the test suite. See SECURITY.md for the full security model, threat boundaries, and hardening guide.

Security

• Sealed & confidential access control — restricted to parties, counsel of record, the filer, and court staff; counsel is matched by account linkage or a verified bar number, never a self-asserted one.
• Upload malware screening — every upload is screened (built-in executable/EICAR heuristic, optional ClamAV) and rejected before storage.
• MCR 1.109 PII warnings at upload — likely SSNs, dates of birth, and account numbers are flagged for redaction.
• Hardened authentication — Keycloak RS256 JWTs (signature, issuer, expiry verified; no none algorithm); OIDC auto-provisioning requires a verified email and won't adopt privileged accounts.
• Audit logging & ownership checks on every object, with parameterized queries throughout.

Court Rule compliance

• MCR 1.109 — text-searchable PDFs, electronic signatures, PII detection
• MCR 2.002 — fee waiver support for indigent filers
• MCR 2.119 — motion companion documents (brief, proposed order)
• MCR 2.313 — meet-and-confer certification for discovery motions
• WCAG 2.1 AA — accessibility compliance

Why this is lower-risk than the status quo: one auditable, open-source codebase (shipping a documented security review and SECURITY.md) instead of multiple closed vendor systems — and no lock-in: identity, payments, and the system-of-record CMS stay with the court (see the threat-boundary table in SECURITY.md).

Known Limitations & Roadmap

MUEFS is a working proof of concept — some parts (live CMS integration, payments) are deliberately demo-grade. See docs/ROADMAP.md for an honest accounting of what is production-ready vs. demonstration, plus the planned roadmap.

License

AGPL-3.0 License — See LICENSE for details.

This project is open source to remove the barriers to building a unified Michigan e-filing system.