Plaid'IA

Assistant IA de préparation de plaidoirie — France & espace OHADA

Analyse de conclusions adverses, plan de plaidoirie chronométré, simulateur d'objections, chronologie automatique, vérification procédurale — avec un garde-fou anti-hallucination visible à chaque réponse.

Démo en ligne (sans inscription, cliquer sur « Essayer la démo ») · Documentation API

---

🇬🇧 An English summary follows the French documentation — see English summary below.

Aperçu

📸 Capture d'écran à ajouter ici une fois le premier déploiement public effectué (voir DEPLOIEMENT.md) — placez-la dans docs/screenshot-landing.png et remplacez ce paragraphe par ![Aperçu de la page d'accueil](docs/screenshot-landing.png).

Présentation

Plaid'IA est un outil d'aide à la préparation de dossiers, à destination des avocats (espace Avocat) et des greffiers/magistrats (espace Greffier). Il ne rend pas d'avis juridique et ne remplace pas l'analyse d'un professionnel du droit — c'est un assistant de préparation, pas un système de décision.

Le projet est né comme une application de bureau (Tkinter, voir gui.py à la racine du dépôt) avant d'être exposée comme une API web (FastAPI) consommée par un front séparé (React). Toute la logique métier — appels à Claude, extraction de documents, export Word/PDF, recherche juridique — vit dans les modules Python à la racine du dépôt et est réutilisée telle quelle par le backend web, sans être dupliquée ni réécrite.

Fonctionnalités

Espace Avocat

Section	Fonctionnalités
Poser une question	Chat juridique multi-tours en streaming, recherche live Légifrance/Judilibre optionnelle
L'Arsenal	Analyser des conclusions adverses (syllogisme juridique), résumer un dossier, générer un plan de plaidoirie chronométré, simuler les objections probables, rapport complet, analyse stylistique des conclusions adverses, vérification procédurale
La Chemise	Parcourir/rechercher tous les dossiers, fiche dossier + historique des analyses, import de documents par glisser-déposer
Le Grimoire	Consulter/collecter/valider la jurisprudence, gérer un corpus juridique multi-source (OHADA, UE, droit sénégalais...), régler la juridiction active
Le Carnet	Prise de note structurée par l'IA, timeline des notes, rédaction d'une note client en langage simple

Espace Greffier / Magistrat

Chronologie automatique d'une affaire, extraction d'éléments clés d'un document, classement automatique, contrôle de cohérence entre documents, recherche transversale dans toutes les affaires, rédaction de PV d'audience, vérification procédurale, analyse de réquisitoire et de rapport d'instruction.

Garde-fous anti-hallucination

• Balisage des références juridiques : chaque prompt système impose au modèle d'encadrer toute référence juridique d'une balise structurée ([ART:<numéro>:<code>], [JURISPRUDENCE:<référence>]) et, s'il n'est pas certain de la citer correctement, [VERIF:<description>] plutôt que de l'affirmer comme un fait établi — voir analyse.REGLE_BALISAGE_CITATIONS. Le front repère ces balises dans n'importe quel texte produit (chat en streaming inclus) et leur donne un rendu visuel dédié — voir frontend/src/components/RichOutput.tsx.
• Syllogisme juridique imposé : les prompts d'analyse de conclusions et de réponse au chat exigent explicitement l'enchaînement faits → problème de droit → règle applicable → application aux faits → conclusion, plutôt qu'une conclusion présentée sans justification traçable (voir analyse.py).
• Jurisprudence jamais citée sans validation humaine : toute référence collectée automatiquement (Judilibre) reste « en attente » tant qu'un avocat ne l'a pas validée manuellement — jamais utilisable en contexte avant ça (voir db.py, table jurisprudence).
• Mode démo transparent : sur un déploiement public sans clé API, les réponses préenregistrées sont clairement annoncées comme telles (bandeau "Mode démo"), jamais présentées comme une analyse réelle.

Architecture

┌──────────────────────────┐            ┌───────────────────────────────┐
│   Frontend (Vercel)      │   HTTPS    │   Backend (Render)             │
│   React + Vite + TS      │───────────▶│   FastAPI (Python)             │
│   Tailwind · Zustand     │◀───────────│                                 │
│                          │  JSON/SSE  │   /api/dossiers                │
│   "/"      → Landing     │            │   /api/analyse                 │
│   "/app/*" → App (SPA)   │            │   /api/jurisprudence           │
└──────────────────────────┘            │   /api/notes                   │
                                         │   /api/greffier                │
                                         │   /api/chat   (streaming SSE)  │
                                         │   /api/intention               │
                                         │   /api/config                  │
                                         └────────────────┬────────────────┘
                                                           │
                             ┌─────────────────────────────┼─────────────────────────────┐
                             │                             │                             │
                   ┌─────────▼─────────┐         ┌─────────▼─────────┐         ┌─────────▼─────────┐
                   │ Modules métier     │         │ SQLite             │         │ API Anthropic      │
                   │ (racine du dépôt)  │         │ (plaidoirie.db)    │         │ Claude              │
                   │                    │         │                    │         │                     │
                   │ analyse.py         │         │ dossiers           │         │ ou réponses          │
                   │ db.py              │         │ analyses           │         │ préenregistrées      │
                   │ recherche_         │         │ notes              │         │ (mode démo, voir     │
                   │   juridique.py     │         │ jurisprudence      │         │ backend/app/demo.py) │
                   │ judilibre.py       │         │ corpus_juridique   │         └───────────────────────┘
                   │ extract.py         │         │ conversations_chat │
                   │ export.py          │         └────────────────────┘
                   │ legifrance.py      │
                   └────────────────────┘

backend/app/bootstrap.py ajoute la racine du dépôt à sys.path pour importer ces modules sans les copier — un seul jeu de fichiers, jamais deux versions à synchroniser entre l'ancienne app Tkinter et l'API web.

Stack technique

Composant	Techno
Backend	FastAPI, Pydantic v2, slowapi (débit par IP), SQLite
IA	API Anthropic (Claude)
Frontend	React 18, Vite, TypeScript, React Router, Zustand, Tailwind CSS
Tests	pytest (backend), Vitest + Testing Library (frontend)
Déploiement	Docker (backend, Render/Railway), Vercel (frontend)

Installation locale

Prérequis : Python 3.11+, Node.js 18+.

git clone https://github.com/<votre-compte>/plaidia.git
cd plaidia

Backend (voir backend/README.md pour le détail complet) :

cd backend
python -m venv venv
venv\Scripts\activate        # Windows — macOS/Linux : source venv/bin/activate
pip install -r requirements.txt
copy .env.example .env       # macOS/Linux : cp .env.example .env
# Renseignez ANTHROPIC_API_KEY dans backend/.env, ou laissez vide pour
# démarrer directement en mode démo.
uvicorn app.main:app --reload --port 8000

Frontend, dans un second terminal :

cd frontend
npm install
copy .env.example .env       # macOS/Linux : cp .env.example .env
npm run dev

L'app est alors sur http://localhost:5173, l'API sur http://localhost:8000/docs.

Ou en une seule commande, une fois les deux installations ci-dessus faites (venv Python activé + dépendances backend installées, npm install fait dans frontend/) :

npm install   # une seule fois, à la racine (installe concurrently)
npm run dev   # lance backend (:8000) ET frontend (:5173) ensemble, Ctrl+C arrête les deux

Alternative avec make (macOS/Linux, ou Windows via WSL/Git Bash) : make install puis make dev.

Tests

# Modules métier racine (pytest — db.py, cli.py, export.py, extract.py...)
pip install -r requirements.txt -r backend/requirements-dev.txt && pytest

# Backend API (pytest, mode démo — n'appelle jamais l'API Anthropic ni la base réelle)
cd backend && pip install -r requirements-dev.txt && pytest

# Frontend (Vitest)
cd frontend && npm install && npm test

Les trois d'un coup depuis la racine : npm run test (voir package.json) ou make test. Ce sont deux suites pytest distinctes (tests/ à la racine et backend/tests/) — pytest.ini résout testpaths = tests relativement au répertoire d'où la commande est lancée, donc bien lancer les deux commandes séparément (ou passer par npm run test/make test, qui le font déjà).

Voir la section "Ce qui reste imparfait" plus bas pour la portée exacte de cette suite de tests — volontairement minimale, pas une couverture exhaustive.

Déploiement

Guide complet, pas à pas, avec Dockerfile, render.yaml, vercel.json et la liste exacte des variables d'environnement : DEPLOIEMENT.md.

Lien de démo : https://plaidia.vercel.app — sans inscription. Hébergement gratuit : le premier chargement peut prendre 30 à 60 secondes (réveil du serveur).

Limitations connues

Liste honnête, à date — voir la conversation de développement pour le détail complet de chaque point :

• Couverture de tests backend volontairement minimale : couvre le mode démo (réponses cannées, blocage 503, limite de taille, bascule clé personnelle) mais pas les routes CRUD complètes, pas les exports Word/PDF, pas le déclenchement réel du débit limite (slowapi).
• Bundle frontend au-dessus du seuil de 500 kB (vite build avertit sur index-*.js, ~618 kB avant gzip) : pas bloquant, mais un import() dynamique sur les écrans les moins visités réduirait le temps de premier chargement.
• render.yaml/railway.json validés comme YAML/JSON syntaxiquement corrects, pas contre le schéma réel de chaque plateforme (jamais testés sur un vrai compte) — une configuration manuelle de repli est documentée dans DEPLOIEMENT.md si l'import automatique échoue.
• docker build jamais lancé réellement (Docker indisponible en développement) — la structure de copie du Dockerfile a été reproduite et testée manuellement, mais pas le build Docker lui-même.
• Pas de relecture orthographique exhaustive du texte français sur l'ensemble de l'app (plusieurs dizaines de pages) — une recherche ciblée n'a trouvé aucun résidu d'anglais, mais une relecture ligne à ligne complète n'a pas été faite.

Auteur

Abdoulaye Sadio — Projet portfolio, NLP / TAL (Traitement Automatique des Langues).

• GitHub : abdoulayesadio701-rgb
• LinkedIn : abdoulaye-sadio

---

English summary

Plaid'IA is an AI assistant for legal case preparation, built for two audiences: lawyers (adverse-argument analysis with explicit legal syllogism, timed pleading plans, objection simulation, procedural deadline checks) and court clerks/magistrates (automatic case timelines, document classification, cross-document consistency checks, hearing minutes drafting).

Anti-hallucination guardrails are the core design principle: every system prompt requires the model to wrap every legal citation in a structured tag ([ART:<number>:<code>], [JURISPRUDENCE:<reference>]) and, when it isn't fully certain about one, [VERIF:<description>] instead of stating it as an established fact — each tag rendered with its own visual treatment everywhere in the UI, including live-streamed chat responses. Automatically collected case law is never citable until a human validates it. A transparent demo mode serves realistic pre-recorded responses (no API key required, no real Claude calls) when no API key is configured server-side, with a visible banner so nobody mistakes a demo answer for a real one; visitors can optionally supply their own Anthropic key (stored client-side only, in sessionStorage, sent as a header, never logged server-side) to get live answers instead.

Stack: FastAPI + SQLite + Anthropic Claude on the backend (deployed as a Docker image on Render), React + Vite + TypeScript + Tailwind + Zustand on the frontend (deployed on Vercel). The backend reuses a set of pre-existing Python modules (analyse.py, db.py, extract.py, export.py...) from the project's original Tkinter desktop app without rewriting them — see the architecture diagram above.

Quick start: npm install && npm run dev from the repo root (see package.json) runs both the backend (uvicorn) and the frontend (vite) concurrently. Full step-by-step setup, testing, and deployment instructions are in the French sections above and in DEPLOIEMENT.md (deployment steps are language-neutral — commands and file names read the same either way).

Live demo: https://plaidia.vercel.app (no sign-up; the first load may take 30-60 s while the free-tier server wakes up)

Author: Abdoulaye Sadio — portfolio project, NLP. GitHub: abdoulayesadio701-rgb · LinkedIn: abdoulaye-sadio.