Compendium Sui Juris

Évalue les logiciels sous 7 axes de souveraineté numérique, gère des profils utilisateur, et découvre des alternatives via un graphe de connaissances.

Stack : FastAPI · Neo4j · MeiliSearch · FastMCP · Gradio · Keycloak · Celery

Workbook associé

L'application d'audit workbook est disponible séparément : Charta Codicum

---

Table des matières

1. Outils MCP
2. API
3. Architecture
4. Installation
5. Authentification
6. Modèle de données
7. Guide utilisateur
8. Guide développeur
9. Interface Gradio
10. Protection de la vie privée

---

1. Outils MCP

Tous les outils MCP (27 outils) sont accessibles via le serveur FastMCP (HTTP ou protocole MCP natif) pour intégration avec un agent LLM (Claude Code, OpenCode, etc.).

graph LR
    A[Agent LLM<br/>Claude Code / OpenCode] -->|MCP Tools| B[FastMCP Server]
    B -->|REST| C[API Layer]
    C --> D[(Neo4j<br/>Knowledge Graph)]
    C --> E[(MeiliSearch<br/>Full-text)]

Outils disponibles

Outil	Description	Usage typique
search_software(query, filters, limit)	Recherche full-text	Trouver un logiciel
get_software_analysis(software_id)	Détail d'analyse validée	Voir les scores
list_alternatives(query, category, target_expertise, limit)	Alternatives legacy	Filtrer alternatives
get_recommendation(software_id, target_expertise, max_results)	Recommandations	Suggérer alternatives
compare_software(id1, id2)	Comparaison simple	Tableau comparatif
get_sovereignty_score(software_id)	Score global + grade	Résumé souveraineté
find_alternatives_for_software(software_id)	Alternatives via graphe	Alternatives directes
compare_software_v2(id1, id2)	Comparaison enrichie	Tableau + features + recommandation
create_user_profile(username, ...)	Créer profil utilisateur	Nouvel utilisateur
update_user_profile(user_id, updates)	Modifier profil	Ajuster besoins/niveau
get_user_profile(user_id)	Consulter profil	Données utilisateur
ingest_data(source_type, source_url, ...)	Ingérer des données	Enrichir depuis sources
add_software_feature(software_id, feature_name, ...)	Ajouter fonctionnalité	Enrichir logiciel
add_software_alternative_link(id1, id2, ...)	Lier deux logiciels	Créer alternative
create_corporation(name, ...)	Ajouter une corporation (ESG)	Nouvelle entreprise
create_person(name, ...)	Ajouter une personne physique	Nouvel individu
batch_create(nodes, relationships)	Batch transactionnel	Création masse
execute_cypher(query, params)	Exécuter du Cypher arbitraire	Opérations avancées
create_meili_item(content, entity_id, ...)	Ajouter un fait textuel indexé	Fact item
search_meili_items(query, ...)	Recherche plein texte dans MeiliSearch	Recherche de faits
link_owner(corp_id, sw_id, ...)	Lien de propriété (OWNS)	Propriété logicielle
link_subprocessor(sw_id, sub_id, ...)	Lien de sous-traitance	Sous-traitant
create_ideology(name, ...)	Ajouter une idéologie	Nouveau concept
link_person_ideology(person_id, ideology_id)	Associer personne → idéologie	Adhésion
link_corporation_ideology(corp_id, ideology_id)	Associer corporation → idéologie	Adhésion
link_software_ideology(sw_id, ideology_id)	Associer logiciel → idéologie	Implémentation
analyze_software_website(url, software_id)	Analyser un site web	Crawler + LLM
get_analysis_task_status(task_id)	Statut d'une tâche d'analyse	Suivi

Configuration Claude Code

Le serveur MCP est exposé via l'API Docker (http://localhost:8000/mcp). Ajoutez ces blocs à votre fichier ~/.claude/settings.json selon votre rôle.

Utilisateur standard — accès aux outils de recherche, consultation et recommandation :

{
  "mcpServers": {
    "compendium": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Administrateur — accès complet (nécessite de définir ADMIN_API_TOKEN dans votre .env avant de lancer Docker Compose) :

{
  "mcpServers": {
    "compendium": {
      "url": "http://localhost:8000/mcp",
      "headers": {
        "Authorization": "Bearer votre-token-admin"
      }
    }
  }
}

Cas d'usage typiques avec un agent

1. Ingérer un rapport d'étude :

L'agent reçoit un lien, appelle ingest_data(source_type="REPORT", source_url="...")
→ enrichit le profil d'un logiciel existant ou crée des liens d'alternative

2. Comparer deux logiciels :

L'agent appelle compare_software_v2 pour obtenir un tableau comparatif
→ génère une réponse structurée pour l'utilisateur

3. Trouver des alternatives :

L'agent appelle find_alternatives_for_software(software_id)
→ parcourt le graphe IS_ALTERNATIVE_TO et présente les résultats

4. Améliorer un profil :

L'agent appelle update_user_profile(user_id, {...})
→ met à jour l'expertise, les besoins, les préférences de l'utilisateur

---

2. API

Endpoints Authentification

Méthode	Endpoint	Description
GET	/api/v1/auth/login	Redirige vers Keycloak
GET	/api/v1/auth/me	Profil utilisateur courant (JWT)
GET	/api/v1/auth/me/profile	Profil complet (JWT)
GET	/api/v1/auth/keycloak-config	Config frontend Keycloak
GET	/api/v1/admin/users	Liste utilisateurs (admin token)
GET	/api/v1/admin/users/{id}	Détail utilisateur (admin token)
PUT	/api/v1/admin/users/{id}/permissions	Modifier permissions (admin token)

Endpoints Software

Méthode	Endpoint	Description
POST	/api/v1/software	Créer un logiciel
GET	/api/v1/software	Lister (paginated)
GET	/api/v1/software/{id}	Détail
DELETE	/api/v1/software/{id}	Supprimer (cascade)
POST	/api/v1/software/{id}/inputs	Ajouter une source
GET	/api/v1/software/{id}/inputs	Lister les sources
POST	/api/v1/software/{id}/analyze	Lancer l'analyse
GET	/api/v1/software/{id}/analysis	Résultat
PUT	/api/v1/software/{id}/analysis/approve	Approuver
PUT	/api/v1/software/{id}/analysis/reject	Rejeter
POST	/api/v1/software/{id}/subprocessors	Ajouter sous-traitant
GET	/api/v1/software/{id}/subprocessors	Sous-traitants

Endpoints Corporations

Méthode	Endpoint	Description
POST	/api/v1/corporations	Créer une corporation
GET	/api/v1/corporations	Lister
GET	/api/v1/corporations/{id}	Détail (avec ESG overall)
PUT	/api/v1/corporations/{id}	Modifier
DELETE	/api/v1/corporations/{id}	Supprimer
POST	/api/v1/corporations/{id}/ownership	Ajouter une propriété logicielle
GET	/api/v1/corporations/{id}/ownership	Logiciels possédés
POST	/api/v1/corporations/{id}/employees	Ajouter un employé
GET	/api/v1/corporations/{id}/employees	Employés

Endpoints Personnes

Méthode	Endpoint	Description
POST	/api/v1/people	Créer une personne
GET	/api/v1/people	Lister
GET	/api/v1/people/{id}	Détail
PUT	/api/v1/people/{id}	Modifier
DELETE	/api/v1/people/{id}	Supprimer
GET	/api/v1/people/{id}/employers	Employeurs
POST	/api/v1/people/{id}/relations	Lier à une autre personne
GET	/api/v1/people/{id}/relations	Relations interpersonnelles

Endpoints Idéologies

Méthode	Endpoint	Description
POST	/api/v1/ideologies	Créer une idéologie
GET	/api/v1/ideologies	Lister
GET	/api/v1/ideologies/{id}	Détail
PUT	/api/v1/ideologies/{id}	Modifier
DELETE	/api/v1/ideologies/{id}	Supprimer
POST	/api/v1/ideologies/link-person	Lier une personne à une idéologie
GET	/api/v1/ideologies/by-person/{id}	Idéologies d'une personne
POST	/api/v1/ideologies/link-corporation	Lier une corporation à une idéologie
GET	/api/v1/ideologies/by-corporation/{id}	Idéologies d'une corporation
POST	/api/v1/ideologies/link-software	Lier un logiciel à une idéologie
GET	/api/v1/ideologies/by-software/{id}	Idéologies d'un logiciel

Endpoints Alternatives

Méthode	Endpoint	Description
POST	/api/v1/alternatives	Créer (legacy)
GET	/api/v1/alternatives	Lister (legacy)
GET	/api/v1/alternatives/{id}	Détail
PUT	/api/v1/alternatives/{id}	Modifier
DELETE	/api/v1/alternatives/{id}	Supprimer
POST	/api/v1/alternatives/link	Lien IS_ALTERNATIVE_TO
GET	/api/v1/alternatives/{software_id}/alternatives-v2	Alternatives via graphe

Endpoints Utilisateurs

Méthode	Endpoint	Description
POST	/api/v1/users	Créer un profil
GET	/api/v1/users/{id}	Détail
GET	/api/v1/users/by-username/{username}	Recherche par nom
PUT	/api/v1/users/{id}	Modifier
DELETE	/api/v1/users/{id}	Supprimer
POST	/api/v1/users/{id}/software	Lier un logiciel (USES)
GET	/api/v1/users/{id}/software	Logiciels utilisés
POST	/api/v1/users/{id}/needs	Ajouter un besoin (HAS_NEED)
GET	/api/v1/users/{id}/needs	Besoins fonctionnels
POST	/api/v1/users/{id}/characteristics	Ajouter caractéristique
GET	/api/v1/users/{id}/characteristics	Caractéristiques

Endpoints Fonctionnalités

Méthode	Endpoint	Description
POST	/api/v1/features	Créer
GET	/api/v1/features	Lister
GET	/api/v1/features/{id}	Détail
DELETE	/api/v1/features/{id}	Supprimer
POST	/api/v1/features/link-software	Lier à un logiciel
GET	/api/v1/features/by-software/{software_id}	Fonctionnalités d'un logiciel

Endpoints Batch

Méthode	Endpoint	Description
POST	/api/v1/batch	Batch transactionnel : créer nœuds + relations
POST	/api/v1/batch-write	Batch extraction
POST	/api/v1/extract-from-text	Extraction IA d'entités depuis du texte

Endpoints MeiliSearchItem (faits)

Méthode	Endpoint	Description
POST	/api/v1/meili-items	Créer un fait lié à une entité
GET	/api/v1/meili-items/{id}	Détail d'un fait
DELETE	/api/v1/meili-items/{id}	Supprimer un fait
POST	/api/v1/meili-items/search	Rechercher des faits
GET	/api/v1/meili-items	Lister les faits depuis Neo4j

Administration (token admin requis)

Méthode	Endpoint	Description
POST	/api/v1/admin/cypher	Exécuter du Cypher arbitraire

Autres endpoints

Méthode	Endpoint	Description
POST	/api/v1/search	Recherche full-text (legacy)
GET	/api/v1/search/suggestions	Autocomplete (legacy)
POST	/api/v1/llm-configs	Config LLM
POST	/api/v1/llm-configs/{id}/test	Tester connexion
GET	/api/v1/rdf/software[/{id}]	Export RDF logiciel(s)
GET	/api/v1/rdf/corporation[/{id}]	Export RDF corporation(s)
GET	/api/v1/rdf/person/{id}	Export RDF personne
GET	/api/v1/rdf/node/{label}/{id}	Export RDF générique
GET	/api/v1/rdf/export	Export RDF complet
GET	/api/v1/rdf/sparql	SPARQL endpoint
POST	/api/v1/chatbot/chat	Chat avec détection de commandes
POST	/api/v1/chatbot/analyze	Analyse de site web
GET	/api/v1/chatbot/status/{task_id}	Statut d'analyse
GET	/api/v1/chatbot/tasks	Liste des tâches récentes

---

3. Architecture

graph TB
    subgraph "Clients"
        UI[Gradio UI]
        REST[Swagger / curl]
        AGENT[Claude Code / OpenCode]
        BROWSER[Browser Login]
        WORKBOOK[Charta Codicum<br/>Workbook App]
    end

    subgraph "Auth"
        KC[Keycloak<br/>port 8080]
    end

    subgraph "FastAPI (port 8000)"
        ROUTES[Routes REST]
        MCP[FastMCP Server]
        LLM[LLM Pipeline<br/>OpenAI-compatible]
        AUTH[Auth Middleware<br/>JWT Verification]
    end

    subgraph "Async"
        CELERY[Celery Worker<br/>analyse + crawl]
        RABBIT[RabbitMQ]
    end

    subgraph "Stockage"
        NEO4J[(Neo4j<br/>Knowledge Graph)]
        MEILI[(MeiliSearch<br/>Full-text Search)]
    end

    UI --> ROUTES
    REST --> ROUTES
    WORKBOOK --> ROUTES
    BROWSER --> KC
    KC -->|JWT| REST
    AGENT -->|MCP Protocol| MCP
    ROUTES --> AUTH
    AUTH --> KC
    ROUTES --> LLM
    ROUTES --> NEO4J
    ROUTES --> MEILI
    MCP --> NEO4J
    MCP --> MEILI
    CELERY --> RABBIT
    CELERY --> LLM
    CELERY --> NEO4J
    CELERY --> MEILI

Workflow d'analyse LLM

sequenceDiagram
    participant U as Utilisateur
    participant API as API
    participant CEL as Celery
    participant LLM as LLM
    participant DB as Neo4j
    participant MS as MeiliSearch

    U->>API: POST /chatbot/analyze (url)
    API->>CEL: dispatch analyze_software_website
    CEL->>LLM: crawl + extract
    LLM->>CEL: structured data
    CEL->>DB: CREATE nodes + relationships
    CEL->>MS: index
    API->>U: task_id
    U->>API: GET /chatbot/status/{task_id}
    API->>U: COMPLETED + result

---

4. Installation

Prérequis

• Docker & Docker Compose
• ou Python 3.11+ avec Poetry/uv

Avec Docker (recommandé)

git clone https://git.jevalide.ca/partage/compendium-sui-juris
cd compendium-sui-juris
make env
docker compose up -d

Accès :

• API : http://localhost:8000
• Swagger UI : http://localhost:8000/docs
• MeiliSearch Dashboard : http://localhost:7701
• Neo4j Browser : http://localhost:7474
• Gradio UI : http://localhost:7860
• Chatbot : http://localhost:7865
• Keycloak : http://localhost:8080 (admin/admin)

Sans Docker

# Poetry
poetry install
poetry run uvicorn src.main:app --reload

# uv
uv pip install -e .
uvicorn src.main:app --reload

Configuration

Variables d'environnement (fichier .env ou docker-compose) :

Variable	Description	Défaut
NEO4J_URI	Connexion Neo4j	bolt://localhost:7687
NEO4J_USER	Utilisateur Neo4j	neo4j
NEO4J_PASSWORD	Mot de passe Neo4j	password
MEILISEARCH_URL	URL MeiliSearch	http://localhost:7700
MEILISEARCH_API_KEY	Clé API MeiliSearch	(vide)
LLM_DEFAULT_BASE_URL	URL LLM OpenAI-compatible	https://api.openai.com/v1
LLM_DEFAULT_MODEL	Modèle LLM par défaut	gpt-4o
LLM_API_KEY	Clé API LLM	(vide)
KEYCLOAK_URL	URL Keycloak	http://localhost:8080
KEYCLOAK_REALM	Realm Keycloak	charta-codicum
KEYCLOAK_CLIENT_ID	Client ID OIDC	charta-api
ADMIN_API_TOKEN	Token admin statique	changeme-admin-token

---

5. Authentification

L'authentification est gérée par Keycloak avec support de connexion sociale Google et GitHub.

sequenceDiagram
    participant U as Utilisateur
    participant KC as Keycloak
    participant API as API
    participant DB as Neo4j

    U->>KC: Login (Google/GitHub/mot de passe)
    KC->>U: JWT token
    U->>API: API call + Bearer JWT
    API->>KC: Vérifie JWT via JWKS
    API->>DB: Crée/synchronise UserProfile
    API->>U: Réponse

Obtenir un token

Via le flux direct (mot de passe) :

curl -X POST http://localhost:8080/realms/charta-codicum/protocol/openid-connect/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "client_id=charta-api" \
  -d "username=user" \
  -d "password=user" \
  -d "grant_type=password"

Via la page de connexion :

Ouvrir http://localhost:8000/api/v1/auth/login dans un navigateur.

Configurer Google / GitHub

Pour activer la connexion sociale :

1. Accéder à l'admin console Keycloak : http://localhost:8080 (admin/admin)
2. Aller dans le realm charta-codicum → Identity Providers
3. Activer Google : fournir Client ID et Client Secret (console développeur Google)
4. Activer GitHub : fournir Client ID et Client Secret (paramètres développeur GitHub)

Les redirect URIs Keycloak sont :

http://localhost:8080/realms/charta-codicum/broker/google/endpoint
http://localhost:8080/realms/charta-codicum/broker/github/endpoint

Token admin statique

Un token admin est défini dans la variable d'environnement ADMIN_API_TOKEN (défaut : changeme-admin-token). Utilisé pour les endpoints d'administration :

curl -H "Authorization: Bearer changeme-admin-token" \
  http://localhost:8000/api/v1/admin/users

Permissions

Permission	Accès
read	Consultation des logiciels et analyses
write	Création/modification de données
admin	Tous les accès + gestion des permissions

---

6. Modèle de données

Le système repose sur un graphe de connaissances Neo4j avec les types de nœuds et relations suivants :

Types de nœuds

Nœud	Description	Propriétés clés
Software	Logiciel analysé	id, name, version, website, source_url
AnalysisInput	Source documentaire	id, url, url_type, raw_content
SoftwareAnalysis	Analyse LLM validée	id, scores (7 axes), status, raw_llm_response
Feature	Fonctionnalité/capacité	id, name, description, category
Alternative	Alternative standalone	id, name, sovereignty_score, pros/cons
UserProfile	Profil utilisateur	id, username, expertise_level, company
UserCharacteristic	Caractéristique utilisateur	id, key, value
UserLLMConfig	Configuration LLM	id, name, base_url, model_name, is_active
Corporation	Entreprise propriétaire	id, name, website, esg_environmental, esg_social, esg_governance
Person	Personne physique	id, name, wealth, title, email
Ideology	Idéologie / philosophie	id, name, description, category
MeiliSearchItem	Fait textuel indexé	id, content, entity_id, entity_label, category, source
SoftwareAnalysisTask	Tâche d'analyse Celery	id, software_id, status, url

Relations

Relation	Source → Cible	Propriétés	Description
HAS_INPUT	Software → AnalysisInput	—	Sources documentaires
HAS_ANALYSIS	Software → SoftwareAnalysis	—	Analyse LLM
HAS_FEATURE	Software → Feature	—	Fonctionnalité offerte
HAS_ALTERNATIVE	Software → Alternative	—	Alternative (legacy)
IS_ALTERNATIVE_TO	Software → Software	shared_feature_ids, alternative_type	Alternative entre logiciels
SUBPROCESSES	Software → Software	description, data_types	Sous-traitance
IMPLEMENTS	Software → Ideology	—	Idéologie mise en œuvre
USES	UserProfile → Software	purpose, context	Logiciel utilisé
HAS_NEED	UserProfile → Feature	—	Besoin fonctionnel
HAS_CHARACTERISTIC	UserProfile → UserCharacteristic	—	Attribut utilisateur
HAS_CONFIG	UserProfile → UserLLMConfig	—	Configuration LLM
OWNS	Corporation → Software	ownership_percentage, since	Propriété
EMPLOYS	Corporation → Person	role, since	Employé
ADHERES_TO	Person/Corp → Ideology	—	Idéologie
RELATED_TO	Person → Person	relationship_type	Lien interpersonnel
HAS_MEILI_ITEM	* → MeiliSearchItem	—	Fait textuel indexé

Grille de scores (10 axes)

Score	Licence	Données	IA	Consentement	Suivi	Juridiction	Région	Environnement	Propriété	Idéologie
10	GPL/AGPL/MPL	Aucune collecte	Aucun IA	Aucun requis	Aucun	FR	FR	ESG 10	Communauté	Opensource
7	LGPL/EPL/Apache	Minimale	IA locale	Basique	Minimal	EU	EU	ESG ~7	EU	Privacy
4	MIT/BSD	Standard	IA tiers	Étendu	Standard	US	US	ESG ~4	US	Commercial
1	Propriétaire	Extensive	Invasive	Multiples	Extensif	Autre	Autre	ESG ~1	Autre	Surveillance
0	Inconnu	Inconnu	Inconnu	Inconnu	Inconnu	Inconnu	Inconnu	Pas de propriétaire	—	Pas d'idéologie

Score global = moyenne des scores connus (>0 sur 10 axes) → grade A+ (≥ 9) à F (< 3).

---

7. Guide utilisateur

7.1 Ajouter un logiciel

POST /api/v1/software

{
  "name": "Zoom",
  "version": "5.0",
  "website": "https://zoom.us"
}

7.2 Ajouter des sources à analyser

POST /api/v1/software/{id}/inputs

{
  "url": "https://zoom.us/privacy",
  "url_type": "PRIVACY_POLICY",
  "raw_content": "We collect your name, email..."
}

Types : CONTRACT, PRIVACY_POLICY, TERMS, DATA_PROCESSING, OTHER.

7.3 Lancer l'analyse

POST /api/v1/chatbot/analyze

{
  "url": "https://asana.com",
  "software_id": "optional-existing-id"
}

L'analyse passe par 4 phases : CRAWLING → EXTRACTING → WRITING → COMPLETED.

7.4 Gérer les fonctionnalités

POST /api/v1/features

{
  "name": "Visioconférence",
  "description": "Réunions vidéo en temps réel",
  "category": "COMMUNICATION"
}

POST /api/v1/features/link-software

{
  "software_id": "uuid",
  "feature_id": "uuid"
}

7.5 Gérer les corporations

POST /api/v1/corporations

{
  "name": "Acme Corp",
  "website": "https://acme.example.com",
  "esg_environmental": 7,
  "esg_social": 8,
  "esg_governance": 6,
  "country": "FR"
}

Le score esg_overall est calculé automatiquement (moyenne des 3 axes).

7.6 Export RDF / Schema.org

GET /api/v1/rdf/software/{id}
Accept: application/ld+json

Formats supportés : Turtle, JSON-LD, RDF/XML, N3, N-Triples, TriG.

GET /api/v1/rdf/sparql?query=SELECT+?s+?p+?o+WHERE+{?s+?p+?o}+LIMIT+10

---

8. Guide développeur

Structure du projet

compendium-sui-juris/
├── README.md
├── SPEC.md
├── RAPPORT.md
├── PROMPT-ADMIN.txt
├── NEWS.md
├── docker-compose.yml
├── Dockerfile
├── Dockerfile.ui
├── Dockerfile.chatbot
├── pyproject.toml
├── src/
│   ├── main.py              # FastAPI + lifespan
│   ├── config.py             # Settings Pydantic
│   ├── neo4j_database.py     # Wrapper Neo4j CRUD
│   ├── celery_app.py         # Celery worker config
│   ├── api/routes/           # 17 modules REST
│   ├── auth/                 # Keycloak JWT
│   ├── mcp/                  # FastMCP 27 tools
│   ├── services/             # analysis, meilisearch, crawler, etc.
│   ├── tasks/                # Celery tasks
│   ├── schemas/              # Pydantic schemas
│   └── ui/                   # Gradio interfaces
├── tests/
├── scripts/
├── keycloak/
└── backend/pdf_service/

Lancer les tests

poetry run python -m pytest tests/ -v

Étendre le modèle de données

1. Ajouter l'enum dans src/models/models.py
2. Ajouter le schéma Pydantic dans src/schemas/schemas.py
3. Ajouter le label dans init_db() de src/neo4j_database.py
4. Créer les routes API
5. Ajouter les outils MCP correspondants

Ajouter un outil MCP

# 1. Implémentation dans src/mcp/tools.py
def mon_outil_impl(param: str) -> dict:
    db = get_db()
    return db.get_node("Software", param)

# 2. Exposition dans src/mcp/server.py
@mcp.tool()
def mon_outil(param: str) -> dict:
    """Description visible dans l'agent."""
    return mon_outil_impl(param)

Gestion des snapshots DB

# Sauvegarder
./scripts/db-snapshot.sh backup

# Lister
./scripts/db-snapshot.sh list

# Restaurer
./scripts/db-snapshot.sh restore <timestamp>

---

9. Interface Gradio

Deux onglets : Recherche et Saisie de données, plus Tâches.

# Docker
docker compose up -d  # port 7860

# Sans Docker
poetry run python -m src.ui.app

---

10. Protection de la vie privée

Chaque profil utilisateur est isolé et contient des paramètres de confidentialité configurables :

{
  "privacy_settings": {
    "show_sociodemographic": false,
    "show_company": true,
    "show_software_usage": true,
    "data_retention_days": 365
  }
}

• show_sociodemographic : masque les données démographiques
• show_company : masque le nom de l'entreprise
• show_software_usage : masque les logiciels utilisés
• data_retention_days : durée de conservation des données

Recommandations de sécurité

Pour un déploiement en production :

• Chiffrer les informations sensibles (api_key, données démographiques)
• Configurer Neo4j avec authentification renforcée
• Utiliser HTTPS en production
• Restreindre CORS aux origines autorisées
• Changer les tokens et secrets par défaut

Licence

AGPL-3.0 — voir LICENSE