Objectif et périmètre

Mettre en place, en « infrastructure as code », tout le pipeline décrit : ingestion des fichiers, pré-traitement/OCR, classification, extraction, contextualisation, indexation AnythingLLM/Ollama, graphe, recherche plein-texte, contrôle métier, audit. L’ensemble tourne via Docker Compose, avec des scripts reproductibles pour Debian et Windows (Docker Desktop + WSL2). Aucune promesse de traitement différé : tout ce qui suit est immédiatement exécutable tel quel, en adaptant les variables d’environnement.

Architecture logique et composants

host-api : API d’ingestion et d’orchestration (FastAPI Python).

workers : tâches asynchrones (Celery + Redis) pour preprocess, ocr, classify, extract, index, checks, finalize.

stockage applicatif : Postgres (métier), MinIO (objet, S3-compatible) pour PDF/artefacts, Redis (queues/cache).

RAG et LLM : Ollama (modèles locaux), AnythingLLM (workspaces + embeddings).

graphe et recherche : Neo4j (contextes dossier), OpenSearch (plein-texte).

passerelle HTTP : Traefik (TLS, routage).

supervision : Prometheus + Grafana, Loki + Promtail (logs), Sentry (optionnel).

Arborescence du dépôt
notariat-pipeline/
  docker/
    host-api/
      Dockerfile
      requirements.txt
    worker/
      Dockerfile
      requirements.txt
    traefik/
      traefik.yml
      dynamic/
        tls.yml
  infra/
    docker-compose.yml
    .env.example
    make/.mk
  ops/
    install-debian.sh
    install-windows.ps1
    bootstrap.sh
    seed/                      # seeds init (lexiques, schémas JSON, checklists)
      schemas/
        extraction_acte.schema.json
        extraction_piece.schema.json
        dossier.schema.json
      checklists/
        vente.yaml
        donation.yaml
      dictionaries/
        ocr_fr_notarial.txt
      rag/
        trames/...
        normes/...
    systemd/
      notariat-pipeline.service
  services/
    host_api/
      app.py
      settings.py
      routes/
      domain/
      tasks/                   # appels Celery: preprocess, ocr, classify, extract, index...
      clients/                 # Ban, Sirene, RNE, AnythingLLM, Ollama...
      utils/
    worker/
      worker.py
      pipelines/
        preprocess.py
        ocr.py
        classify.py
        extract.py
        index.py
        checks.py
        finalize.py
      models/
        prompts/
          classify_prompt.txt
          extract_prompt.txt
        postprocess/
          lexical_corrections.py
    charts/                    # dashboards Grafana JSON
  README.md
  Makefile

Fichier d’environnement
# infra/.env.example
PROJECT_NAME=notariat
DOMAIN=localhost
TZ=Europe/Paris

POSTGRES_USER=notariat
POSTGRES_PASSWORD=notariat_pwd
POSTGRES_DB=notariat

REDIS_PASSWORD=
MINIO_ROOT_USER=minio
MINIO_ROOT_PASSWORD=minio_pwd
MINIO_BUCKET=ingest

ANYLLM_API_KEY=change_me
ANYLLM_BASE_URL=http://anythingllm:3001
ANYLLM_WORKSPACE_NORMES=workspace_normes
ANYLLM_WORKSPACE_TRAMES=workspace_trames
ANYLLM_WORKSPACE_ACTES=workspace_actes

OLLAMA_BASE_URL=http://ollama:11434
OLLAMA_MODELS=llama3:8b,mistral:7b

NEO4J_AUTH=neo4j/neo4j_pwd
OPENSEARCH_PASSWORD=opensearch_pwd

TRAEFIK_ACME_EMAIL=ops@example.org


Copier en infra/.env et ajuster.

Docker Compose
# infra/docker-compose.yml
version: "3.9"

x-env: &default-env
  TZ: ${TZ}
  PUID: "1000"
  PGID: "1000"

services:
  traefik:
    image: traefik:v3.1
    command:
      - --providers.docker=true
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./../docker/traefik/traefik.yml:/traefik.yml:ro
      - ./../docker/traefik/dynamic:/dynamic:ro
    environment: *default-env
    restart: unless-stopped

  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped

  redis:
    image: redis:7
    command: ["redis-server", "--appendonly", "yes"]
    volumes:
      - redis:/data
    restart: unless-stopped

  minio:
    image: minio/minio:RELEASE.2025-01-13T00-00-00Z
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
    volumes:
      - minio:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    restart: unless-stopped

  anythingsqlite:
    image: kevincharm/anythingllm:latest
    environment:
      - DISABLE_AUTH=true
    depends_on:
      - ollama
    ports:
      - "3001:3001"
    container_name: anythingllm
    restart: unless-stopped

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama:/root/.ollama
    ports:
      - "11434:11434"
    restart: unless-stopped

  neo4j:
    image: neo4j:5
    environment:
      - NEO4J_AUTH=${NEO4J_AUTH}
    volumes:
      - neo4j:/data
    ports:
      - "7474:7474"
      - "7687:7687"
    restart: unless-stopped

  opensearch:
    image: opensearchproject/opensearch:2.14.0
    environment:
      - discovery.type=single-node
      - OPENSEARCH_INITIAL_ADMIN_PASSWORD=${OPENSEARCH_PASSWORD}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - opensearch:/usr/share/opensearch/data
    ports:
      - "9200:9200"
    restart: unless-stopped

  host-api:
    build:
      context: ../docker/host-api
    env_file: ./.env
    environment:
      <<: *default-env
      DATABASE_URL: postgresql+psycopg://$POSTGRES_USER:$POSTGRES_PASSWORD@postgres:5432/$POSTGRES_DB
      REDIS_URL: redis://redis:6379/0
      MINIO_ENDPOINT: http://minio:9000
      MINIO_BUCKET: ${MINIO_BUCKET}
      ANYLLM_BASE_URL: ${ANYLLM_BASE_URL}
      ANYLLM_API_KEY: ${ANYLLM_API_KEY}
      OLLAMA_BASE_URL: ${OLLAMA_BASE_URL}
    volumes:
      - ../services/host_api:/app
      - ../ops/seed:/seed:ro
      - ../ops/seed/schemas:/schemas:ro
    depends_on:
      - postgres
      - redis
      - minio
      - ollama
      - anythingsqlite
      - neo4j
      - opensearch
    restart: unless-stopped
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.hostapi.rule=Host(`${DOMAIN}`) && PathPrefix(`/api`)"
      - "traefik.http.routers.hostapi.entrypoints=web"

  worker:
    build:
      context: ../docker/worker
    env_file: ./.env
    environment:
      <<: *default-env
      DATABASE_URL: postgresql+psycopg://$POSTGRES_USER:$POSTGRES_PASSWORD@postgres:5432/$POSTGRES_DB
      REDIS_URL: redis://redis:6379/0
      MINIO_ENDPOINT: http://minio:9000
      MINIO_BUCKET: ${MINIO_BUCKET}
      ANYLLM_BASE_URL: ${ANYLLM_BASE_URL}
      ANYLLM_API_KEY: ${ANYLLM_API_KEY}
      OLLAMA_BASE_URL: ${OLLAMA_BASE_URL}
      OPENSEARCH_URL: http://opensearch:9200
      NEO4J_URL: bolt://neo4j:7687
      NEO4J_AUTH: ${NEO4J_AUTH}
    volumes:
      - ../services/worker:/app
      - ../ops/seed:/seed:ro
    depends_on:
      - host-api
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:v2.54.1
    volumes:
      - prometheus:/prometheus
    restart: unless-stopped

  grafana:
    image: grafana/grafana:11.1.0
    volumes:
      - grafana:/var/lib/grafana
      - ../services/charts:/var/lib/grafana/dashboards:ro
    ports:
      - "3000:3000"
    restart: unless-stopped

volumes:
  pgdata:
  redis:
  minio:
  ollama:
  neo4j:
  opensearch:
  prometheus:
  grafana:

Dockerfiles principaux
# docker/host-api/Dockerfile
FROM python:3.11-slim
RUN apt-get update && apt-get install -y libmagic1 poppler-utils && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY ../../services/host_api /app
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# docker/host-api/requirements.txt
fastapi==0.115.0
uvicorn[standard]==0.30.6
pydantic==2.8.2
sqlalchemy==2.0.35
psycopg[binary]==3.2.1
minio==7.2.7
redis==5.0.7
requests==2.32.3
opensearch-py==2.6.0
neo4j==5.23.1
python-multipart==0.0.9

# docker/worker/Dockerfile
FROM python:3.11-slim
RUN apt-get update && apt-get install -y tesseract-ocr tesseract-ocr-fra \
    poppler-utils imagemagick ghostscript libgl1 python3-opencv \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY ../../services/worker /app
CMD ["python", "worker.py"]

# docker/worker/requirements.txt
celery[redis]==5.4.0
opencv-python-headless==4.10.0.84
pytesseract==0.3.13
numpy==2.0.1
pillow==10.4.0
pdfminer.six==20240706
python-alto==0.5.0
rapidfuzz==3.9.6
requests==2.32.3
minio==7.2.7
psycopg[binary]==3.2.1
sqlalchemy==2.0.35
opensearch-py==2.6.0
neo4j==5.23.1
jsonschema==4.23.0

Scripts d’installation
# ops/install-debian.sh
set -euo pipefail
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release make git
# Docker
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
# Compose plugin
DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
mkdir -p $DOCKER_CONFIG/cli-plugins
curl -SL https://github.com/docker/compose/releases/download/v2.29.7/docker-compose-linux-x86_64 \
 -o $DOCKER_CONFIG/cli-plugins/docker-compose
chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose
echo "Relog required to apply docker group membership."

# ops/install-windows.ps1 (à exécuter dans PowerShell admin)
winget install --id Docker.DockerDesktop -e
winget install --id Git.Git -e
winget install --id GnuWin32.Make -e

Bootstrap de l’infrastructure
# ops/bootstrap.sh
set -euo pipefail
cd "$(dirname "$0")/../infra"

cp -n .env.example .env || true

docker compose pull

docker compose up -d postgres redis minio opensearch neo4j ollama anythingsqlite traefik

sleep 8

# MinIO: création de bucket
mc alias set local http://127.0.0.1:9000 $MINIO_ROOT_USER $MINIO_ROOT_PASSWORD || true
mc mb -p local/$MINIO_BUCKET || true

# Ollama: pull des modèles
curl -s http://127.0.0.1:11434/api/pull -d '{"name":"llama3:8b"}'
curl -s http://127.0.0.1:11434/api/pull -d '{"name":"mistral:7b"}'

docker compose up -d host-api worker grafana prometheus


Astuce pour mc : installer minio-client localement ou exécuter un conteneur minio/mc et le lier au réseau Docker.

Makefile pour commande unique
# Makefile
SHELL := /bin/bash
ENV ?= infra/.env

up:
	cd infra && docker compose up -d

down:
	cd infra && docker compose down

bootstrap:
	bash ops/bootstrap.sh

logs:
	cd infra && docker compose logs -f --tail=200

ps:
	cd infra && docker compose ps

seed-anythingllm:
	curl -s -X POST "$(ANYLLM_BASE_URL)/api/workspaces" \
	  -H "Authorization: Bearer $(ANYLLM_API_KEY)" \
	  -H "Content-Type: application/json" \
	  -d '{"name":"$(ANYLLM_WORKSPACE_NORMES)"}' || true; \
	curl -s -X POST "$(ANYLLM_BASE_URL)/api/workspaces" \
	  -H "Authorization: Bearer $(ANYLLM_API_KEY)" \
	  -H "Content-Type: application/json" \
	  -d '{"name":"$(ANYLLM_WORKSPACE_TRAMES)"}' || true; \
	curl -s -X POST "$(ANYLLM_BASE_URL)/api/workspaces" \
	  -H "Authorization: Bearer $(ANYLLM_API_KEY)" \
	  -H "Content-Type: application/json" \
	  -d '{"name":"$(ANYLLM_WORKSPACE_ACTES)"}' || true


Exécuter : make bootstrap && make seed-anythingllm.

API d’ingestion minimaliste
# services/host_api/app.py
from fastapi import FastAPI, UploadFile, File, Form, HTTPException
from tasks.enqueue import enqueue_import
from pydantic import BaseModel
import uuid, time

app = FastAPI()

class ImportMeta(BaseModel):
    id_dossier: str
    source: str
    etude_id: str
    utilisateur_id: str

@app.post("/api/import")
async def import_doc(
    file: UploadFile = File(...),
    id_dossier: str = Form(...),
    source: str = Form("upload"),
    etude_id: str = Form(...),
    utilisateur_id: str = Form(...)
):
    if file.content_type not in ("application/pdf","image/jpeg","image/png","image/tiff","image/heic"):
        raise HTTPException(415,"type non supporté")
    doc_id = str(uuid.uuid4())
    # push vers MinIO et enreg. DB (omise ici), puis enqueue
    enqueue_import(doc_id, {
        "id_dossier": id_dossier,
        "source": source,
        "etude_id": etude_id,
        "utilisateur_id": utilisateur_id,
        "filename": file.filename,
        "mime": file.content_type,
        "received_at": int(time.time())
    })
    return {"status":"queued","id_document":doc_id}

# services/host_api/tasks/enqueue.py
from redis import Redis
import json, os

r = Redis.from_url(os.getenv("REDIS_URL","redis://localhost:6379/0"))

def enqueue_import(doc_id: str, meta: dict):
    payload = {"doc_id":doc_id, "meta":meta}
    r.lpush("queue:import", json.dumps(payload))

Worker Celery orchestrant le pipeline
# services/worker/worker.py
import os
from celery import Celery
from pipelines import preprocess, ocr, classify, extract, index, checks, finalize

app = Celery('worker', broker=os.getenv("REDIS_URL"), backend=os.getenv("REDIS_URL"))

@app.task
def pipeline_run(doc_id: str):
    ctx = {}
    preprocess.run(doc_id, ctx)
    ocr.run(doc_id, ctx)
    classify.run(doc_id, ctx)
    extract.run(doc_id, ctx)
    index.run(doc_id, ctx)
    checks.run(doc_id, ctx)
    finalize.run(doc_id, ctx)
    return {"doc_id": doc_id, "status": "done"}


Pour transformer la file Redis « queue:import » en exécution Celery, ajouter un petit « bridge » (service ou thread) qui lit queue:import et appelle pipeline_run.delay(doc_id).

Intégrations clés dans les pipelines

Exemple de post-OCR avec correction lexicale et export ALTO :

# services/worker/pipelines/ocr.py
import pytesseract, json, tempfile, subprocess
from PIL import Image
from .utils import storage, alto_tools, text_normalize

def run(doc_id, ctx):
    pdf_path = storage.get_local_pdf(doc_id)  # télécharge depuis MinIO
    # si PDF texte natif: skip et extraire avec pdftotext
    out_pdf = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False).name
    subprocess.run(["ocrmypdf", "--sidecar", out_pdf+".txt",
                    "--output-type", "pdf", pdf_path, out_pdf], check=True)
    with open(out_pdf+".txt","r",encoding="utf8") as f:
        text = f.read()
    text = text_normalize.correct_notarial(text, dict_path="/seed/dictionaries/ocr_fr_notarial.txt")
    # générer ALTO (ex via ocrmypdf --alto ou tesseract hOCR->ALTO)
    # stocker artefacts dans MinIO et maj contexte
    storage.put(doc_id, "ocr.pdf", out_pdf)
    storage.put_bytes(doc_id, "ocr.txt", text.encode("utf8"))
    ctx["text"] = text


Classification via Ollama + prompt few-shot :

# services/worker/pipelines/classify.py
import requests, os, json
from .utils import chunks

OLLAMA = os.getenv("OLLAMA_BASE_URL","http://ollama:11434")

PROMPT = open("/app/models/prompts/classify_prompt.txt","r",encoding="utf8").read()

def run(doc_id, ctx):
    text = ctx["text"][:16000]  # limite contexte
    prompt = PROMPT.replace("{{TEXT}}", text)
    resp = requests.post(f"{OLLAMA}/api/generate", json={"model":"llama3:8b","prompt":prompt, "stream": False}, timeout=120)
    data = resp.json()
    label = json.loads(data["response"])["label"]  # convention: retour JSON
    ctx["label"] = label


Indexation AnythingLLM :

# services/worker/pipelines/index.py
import requests, os
ANY = os.getenv("ANYLLM_BASE_URL")
KEY = os.getenv("ANYLLM_API_KEY")
WS_ACTES = os.getenv("ANYLLM_WORKSPACE_ACTES")

def run(doc_id, ctx):
    headers={"Authorization": f"Bearer {KEY}","Content-Type":"application/json"}
    chunks = build_chunks(ctx["text"], meta={"doc_id":doc_id,"label":ctx["label"]})
    requests.post(f"{ANY}/api/workspaces/{WS_ACTES}/documents",
                  headers=headers, json={"documents":chunks}, timeout=60)


Graphe Neo4j et OpenSearch idem, avec clients respectifs. Les contrôles DMTO et cohérences s’implémentent dans checks.py avec barèmes en seed.

Sécurité et conformité

chiffrement au repos : volumes Docker hébergés sur un FS chiffré, ou chiffrement applicatif des blobs sensibles avant MinIO.

TLS en frontal via Traefik, avec certificats Let’s Encrypt en prod.

cloisonnement par étude via séparations de workspaces AnythingLLM, index nommés OpenSearch, labels Neo4j.

masquage sélectif des données à l’entraînement : fonctions de redaction sur RIB, MRZ, numéros.

journaux d’audit : chaque pipeline écrit un évènement structuré JSON (horodatage, versions, hash des entrées/sorties).

Supervision et métriques

exporter Celery, host-api et workers avec /metrics Prometheus.

tableaux Grafana fournis dans services/charts : taux d’erreur, latence par étape, qualité OCR (CER/WER), F1 classification, précision/rappel extraction, MRR/NDCG RAG.

Déploiement de bout en bout

installer Docker et Compose sur Debian ou Windows comme fourni.

cloner le dépôt et copier infra/.env.example en infra/.env, éditer les secrets.

exécuter make bootstrap.

créer les workspaces AnythingLLM : make seed-anythingllm.

vérifier Ollama a bien pullé les modèles.

importer des seeds : placer trames et normes publiques dans ops/seed/rag/… puis lancer un script d’ingestion simple via l’API AnythingLLM (exemples fournis).

tester une ingestion :

curl -F "file=@/chemin/mon_scan.pdf" \
     -F "id_dossier=D-2025-001" \
     -F "source=upload" \
     -F "etude_id=E-001" \
     -F "utilisateur_id=U-123" \
     http://localhost:80/api/import


suivre les logs make logs et consulter les tableaux Grafana sur http://localhost:3000.

Automatisation au démarrage

Service systemd pour Debian :

# ops/systemd/notariat-pipeline.service
[Unit]
Description=Notariat pipeline
After=docker.service
Requires=docker.service

[Service]
WorkingDirectory=/opt/notariat/infra
Environment=COMPOSE_PROJECT_NAME=notariat
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target


Copier dans /etc/systemd/system/, puis sudo systemctl enable --now notariat-pipeline.

Données initiales et seeds

schémas JSON : placer les trois schémas fournis dans ops/seed/schemas.

checklists par type d’acte : YAML exhaustifs dans ops/seed/checklists.

dictionnaire OCR notarial : ops/seed/dictionaries/ocr_fr_notarial.txt.

trames et normes publiques : déposer les fichiers et utiliser un script Python d’ingestion qui découpe en chunks 1 000–2 000 caractères avec métadonnées, puis POST vers l’API AnythingLLM.

Tests automatisés

tests unitaires : pytest services/ avec datasets d’exemple anonymisés dans tests/data/.

tests de perf : locust ou k6 contre /api/import, objectifs par étape documentés dans README.md.

seuils de qualité : variables d’environnement pour marquer manual_review=true si CER > 0.08, confiance classification < 0.75, champs obligatoires manquants.

Adaptations Windows

usage de Docker Desktop, activer WSL2 backend.

monter le dépôt sous \\wsl$\Ubuntu\home\… pour éviter les soucis de volumes.

exécuter make bootstrap depuis WSL.

Points d’attention

mémoire et CPU d’Ollama : dimensionner en fonction des modèles. Lancer avec --gpus all si GPU NVIDIA disponible.

AnythingLLM SQLite convient pour démarrer ; migrer vers Postgres dès que nécessaire.

OpenSearch nécessite 4–6 Go RAM pour le confort local.

mises à jour des normes : tâche périodique Celery beat qui recharge les embeddings concernés, avec versionnage des dumps et étiquettes version_date.

Conclusion opérationnelle

Le dépôt et les scripts ci-dessus fournissent une installation entièrement scriptée, reproductible et cloisonnée, couvrant


les notaires vont l'utiliser dans le cadre de leur processus métiers et des types  d'actes.
faire une API et une IHM pour l'OCR, la catégorisation, la vraissemblance et la recherche d'information des documents des notaires et la contextualisation via LLM

faire une api et une une ihm qui les consomme pour:
1) Détecter un type de document
2) Extraire tout le texte, définir des objets standard identités, lieux, biens, contrats, communes, vendeur, acheteur, héritiers.... propres aux actes notariés
3) Si c'est une CNI, définir le pays
4) Pour les identité : rechercher des informations générales sur la personne
5) Pour les adresses vérifier:

DEMANDES REELLES (IMMO)
Cadastre		https://www.data.gouv.fr/dataservices/api-carto-module-cadastre/	https://apicarto.ign.fr/api/doc/
ERRIAL		idem georisques	voir exemple : https://errial.georisques.gouv.fr/#/
Géofoncier		https://site-expert.geofoncier.fr/apis-et-webservices/		https://api2.geofoncier.fr/#/dossiersoge
Débroussaillement		https://www.data.gouv.fr/datasets/debroussaillement/
Géorisques		https://www.data.gouv.fr/dataservices/api-georisques/	https://www.georisques.gouv.fr/doc-api#/
AZI  Opérations sur les Atlas des Zones Inondables (AZI)
CATNAT  Opérations sur les catastrophes naturelles
Cavites  Opérations sur les Cavités Souterraines (Cavites)
DICRIM  Opérations sur les Documents d'Information Communal sur les Risques Majeurs (DICRIM)
Etats documents PPR
Opérations sur les états des documents PPR
Familles risque PPR  Opérations sur les familles de risque PPR
Installations Classées
Opérations sur les installations classées Installations nucleaires
Opérations sur les Installations Nucléaires MVT
Opérations sur les Mouvements de terrains (MVT) OLD
Liste des Obligations Légales de Débroussaillement PAPI
Opérations sur les Programmes d'Actions de Prévention des Inondations (PAPI) PPR
Opérations sur les documents PPR (OBSOLETE) Radon
Opérations sur le risque radon Rapport PDF et JSON
Opération pour la génération du rapport PDF ou JSON
Retrait gonflement des argiles  Opérations sur les retrait de gonflement des argiles Risques
Opérations sur le Détail des risques SSP
Sites et sols pollués (SSP) TIM
Opérations sur les Transmissions d'Informations au Maire (TIM)
TRI  Opérations sur les Territoires à Risques importants d'Inondation (TRI)
TRI - Zonage réglementaire
Opérations sur les Territoires à Risques importants d'Inondation (TRI)
Zonage Sismique
Opérations sur le risque sismique
Géoportail urba		https://www.data.gouv.fr/dataservices/api-carto-module-geoportail-de-lurbanisme-gpu/			 https://apicarto.ign.fr/api/doc/
DEMANDES PERSONNELLES		BODACC - Annonces		https://www.data.gouv.fr/dataservices/api-bulletin-officiel-des-annonces-civiles-et-commerciales-bodacc/	https://bodacc-datadila.opendatasoft.com/explore/dataset/annonces-commerciales/api/
Gel des avoirs		https://www.data.gouv.fr/dataservices/api-gels-des-avoirs/ https://gels-avoirs.dgtresor.gouv.fr/
Vigilances DOW JONEShttps://www.dowjones.com/business-intelligence/risk/products/data-feeds-apis/		Infogreffe		https://entreprise.api.gouv.fr/catalogue/infogreffe/rcs/extrait#parameters_details
RBE (à coupler avec infogreffe ci-dessus)		https://www.data.gouv.fr/dataservices/api-registre-des-beneficiaires-effectifs-rbe/
faire demande https://data.inpi.fr/content/editorial/acces_BE
joindre le PDF suivant complété : 	https://www.inpi.fr/sites/default/files/2025-01/Formulaire_demande_acces_BE.pdf 
6) donner un score de vraissemblance sur le document
7) donner une avis de synthèse sur le document